Arcane  v3.14.10.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
DumpWUCD.cc
1// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
2//-----------------------------------------------------------------------------
3// Copyright 2000-2022 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/* DumpWUCD.cc (C) 2000-2021 */
9/* */
10/* Exportations des fichiers au format UCD. */
11/*---------------------------------------------------------------------------*/
12/*---------------------------------------------------------------------------*/
13
14#include "arcane/utils/String.h"
15#include "arcane/utils/Enumerator.h"
16#include "arcane/utils/Iterator.h"
17#include "arcane/utils/List.h"
18#include "arcane/utils/PlatformUtils.h"
19#include "arcane/utils/Iostream.h"
20#include "arcane/utils/OStringStream.h"
21#include "arcane/utils/ArcanePrecomp.h"
22
23#include "arcane/Item.h"
24#include "arcane/ItemEnumerator.h"
25#include "arcane/IVariable.h"
26#include "arcane/ISubDomain.h"
27#include "arcane/IMesh.h"
28#include "arcane/IMeshSubMeshTransition.h"
29#include "arcane/StdNum.h"
30#include "arcane/ItemGroup.h"
31#include "arcane/IParallelMng.h"
32#include "arcane/Directory.h"
33#include "arcane/PostProcessorWriterBase.h"
34#include "arcane/Service.h"
35#include "arcane/SimpleProperty.h"
36#include "arcane/FactoryService.h"
37#include "arcane/VariableCollection.h"
38
39#include "arcane/std/DumpW.h"
40
41#include <string>
42
43/*---------------------------------------------------------------------------*/
44/*---------------------------------------------------------------------------*/
45
46namespace Arcane
47{
48// NOTE: Ce format ne fonctionne que en séquentiel
49
50/*---------------------------------------------------------------------------*/
51/*---------------------------------------------------------------------------*/
52
53namespace
54{
55Integer code_hex[8] = { 0, 3, 2, 1, 4, 7, 6, 5 };
56Integer code_prism[6] = { 2, 1, 0, 5, 4, 3 };
57Integer code_pyr[5] = { 4, 1, 2, 3, 0 };
58Integer code_tet[4] = { 0, 1, 3, 2 };
59}
60
61/*---------------------------------------------------------------------------*/
62/*---------------------------------------------------------------------------*/
66class DumpWUCD
67: public TraceAccessor
68, public DumpW
69{
70 public:
71
72 DumpWUCD(ISubDomain* sd,IMesh* mesh, const String& filename,
73 RealConstArrayView times, VariableCollection variables);
74 ~DumpWUCD();
75
76 void setMetaData(const String& meta_data) override
77 {
78 ARCANE_UNUSED(meta_data);
79 }
80 String metaData() const { return String(); }
81
82 void writeVal(IVariable&,ConstArrayView<Byte>) override {}
83 void writeVal(IVariable&,ConstArrayView<Real>) override;
84 void writeVal(IVariable&,ConstArrayView<Real2>) override {}
85 void writeVal(IVariable&,ConstArrayView<Real3>) override;
86 void writeVal(IVariable&,ConstArrayView<Int64>) override {}
87 void writeVal(IVariable&,ConstArrayView<Int32>) override {}
88 void writeVal(IVariable&,ConstArrayView<Real2x2>) override {}
89 void writeVal(IVariable&,ConstArrayView<Real3x3>) override {}
90 void writeVal(IVariable&,ConstArrayView<String>) override {}
91
92 void writeVal(IVariable&,ConstArray2View<Byte>) override {}
93 void writeVal(IVariable&,ConstArray2View<Real>) override {}
94 void writeVal(IVariable&,ConstArray2View<Int64>) override {}
95 void writeVal(IVariable&,ConstArray2View<Int32>) override {}
96 void writeVal(IVariable&,ConstArray2View<Real2>) override {}
97 void writeVal(IVariable&,ConstArray2View<Real3>) override {}
98 void writeVal(IVariable&,ConstArray2View<Real2x2>) override {}
99 void writeVal(IVariable&,ConstArray2View<Real3x3>) override {}
100
101 void writeVal(IVariable&,ConstMultiArray2View<Byte>) override {}
102 void writeVal(IVariable&,ConstMultiArray2View<Real>) override {}
103 void writeVal(IVariable&,ConstMultiArray2View<Int64>) override {}
104 void writeVal(IVariable&,ConstMultiArray2View<Int32>) override {}
105 void writeVal(IVariable&,ConstMultiArray2View<Real2>) override {}
106 void writeVal(IVariable&,ConstMultiArray2View<Real3>) override {}
107 void writeVal(IVariable&,ConstMultiArray2View<Real2x2>) override {}
108 void writeVal(IVariable&,ConstMultiArray2View<Real3x3>) override {}
109
110 void beginWrite() override;
111 void endWrite() override;
112
113 private:
114
115 static constexpr Integer m_max_digit = 5;
116 // Nombre de chiffres significatifs pour les afficher les réels.
117 static constexpr Integer MAX_FLOAT_DIGIT = FloatInfo<Real>::maxDigit()+1;
118
119 ISubDomain* m_sub_domain;
120 IMesh* m_mesh;
121 Directory m_base_directory;
122 RealUniqueArray m_times;
123 VariableList m_save_variables;
124
125 UniqueArray<Ref<OStringStream>> m_cell_streams;
126 UniqueArray<Ref<OStringStream>> m_node_streams;
127 UniqueArray<Cell> m_managed_cells;
128};
129
130/*---------------------------------------------------------------------------*/
131/*---------------------------------------------------------------------------*/
132
133DumpWUCD::
134DumpWUCD(ISubDomain* sd,IMesh* mesh,const String& filename,RealConstArrayView times,
135 VariableCollection variables)
136: TraceAccessor(mesh->traceMng())
137, m_sub_domain(sd)
138, m_mesh(mesh)
139, m_base_directory(filename)
140, m_times(times)
141, m_save_variables(variables.clone())
142{
143 m_base_directory.createDirectory();
144
145 // filtrage des cellules
146 // ne sont gardees que les mailles dont le type est reconnue dans UCD
147 ENUMERATE_CELL(it,m_mesh->allCells()){
148 Cell cell = *it;
149 const int type = cell.type();
150 if (type==IT_Vertex || type==IT_Line2 || type==IT_Triangle3
151 || type== IT_Quad4 || type==IT_Hexaedron8 || type==IT_Pyramid5
152 || type==IT_Pentagon5 || type==IT_Tetraedron4)
153 m_managed_cells.add(cell);
154 else
155 info() << "** Warning: cell type " << cell.uniqueId()
156 << " is unknown in UCD format. Cell will be ignored.";
157 }
158
159 Integer nb_cell_var = m_managed_cells.size();
160 Integer nb_node_var = m_mesh->nbNode();
161 m_cell_streams.resize(nb_cell_var);
162 m_node_streams.resize(nb_node_var);
163 for( Integer i=0; i<nb_cell_var; ++i ){
164 m_cell_streams[i] = makeRef(new OStringStream());
165 m_cell_streams[i]->stream().precision(MAX_FLOAT_DIGIT);
166 m_cell_streams[i]->stream().flags(std::ios::scientific);
167 }
168 for( Integer i=0; i<nb_node_var; ++i ){
169 m_node_streams[i] = makeRef(new OStringStream());
170 m_node_streams[i]->stream().precision(MAX_FLOAT_DIGIT);
171 m_node_streams[i]->stream().flags(std::ios::scientific);
172 }
173
174 debug() << "DumpWUCD::DumpWUCD - "
175 << m_mesh->nbCell() << " cells among which "
176 << m_managed_cells.size() << " have a known type";
177}
178
179/*---------------------------------------------------------------------------*/
180/*---------------------------------------------------------------------------*/
181
182DumpWUCD::
183~DumpWUCD()
184{
185}
186
187/*---------------------------------------------------------------------------*/
188/*---------------------------------------------------------------------------*/
194void DumpWUCD::
195writeVal(IVariable& v,ConstArrayView<Real> ptr)
196{
197 info() << "** HERE dump Real variable " << v.name();
198
199 Integer size;
200 switch(v.itemKind())
201 {
202 case (IK_Node):
203 size = ptr.size();
204 for( Integer i=0 ; i<size ; i++)
205 m_node_streams[i]->stream() << " " << ptr[i];
206 break;
207 case (IK_Cell):
208 size = m_managed_cells.size();
209 for( Integer i=0 ; i<size ; i++){
210 const Cell& cell = m_managed_cells[i];
211 m_cell_streams[i]->stream() << " " << ptr[cell.localId()];
212 }
213 break;
214 default:
215 info() << "Variable not managed by UCD writer: " << v.name();
216 }
217}
218
219/*---------------------------------------------------------------------------*/
220/*---------------------------------------------------------------------------*/
226void DumpWUCD::
227writeVal(IVariable& v,ConstArrayView<Real3> ptr)
228{
229 info() << "** HERE dump Real3 variable " << v.name();
230
231 Integer size;
232 switch(v.itemKind())
233 {
234 case (IK_Node):
235 size = ptr.size();
236 for( Integer i=0 ; i<size ; i++) {
237 m_node_streams[i]->stream() << " " << ptr[i].x
238 << " " << ptr[i].y
239 << " " << ptr[i].z;
240 }
241 break;
242 case (IK_Cell):
243 size = m_managed_cells.size();
244 for( Integer i=0 ; i<size ; i++){
245 const Cell cell = m_managed_cells[i];
246 Integer id = cell.localId();
247 m_cell_streams[i]->stream() << " " << ptr[id].x
248 << " " << ptr[id].y
249 << " " << ptr[id].z;
250 }
251 break;
252 default:
253 info() << "Variable not managed by UCD writer: " << v.name();
254 }
255}
256
257/*---------------------------------------------------------------------------*/
258/*---------------------------------------------------------------------------*/
269void DumpWUCD::
270beginWrite()
271{
272 info() << "** Entering method DumpWUCD::writeBegin";
273}
274
275/*---------------------------------------------------------------------------*/
276/*---------------------------------------------------------------------------*/
281void DumpWUCD::
282endWrite()
283{
284 info() << "** Entering method DumpWUCD::writeEnd";
285
286 // Creation du nom de fichier UCD : UCD_<no_iteration>
287 OStringStream ostr;
288 ostr() << "UCD_";
289 ostr().fill('0');
290 ostr().width(m_max_digit);
291 ostr() << m_times.size()-1;
292 ostr() << ".inp\0";
293 String buf = m_base_directory.file(ostr.str());
294 std::ofstream ucd_file(buf.localstr());
295
296 // Ajout de l'entete du fichier
297 // Comptage du nombre de donnees aux noeuds et aux mailles et de leurs
298 // tailles. Les seules methodes "write" implementees sont :
299 // - void writeVal(IVariable& v,ConstArrayView<Real3> a)
300 // - void writeVal(IVariable& v,ConstArrayView<Real> a)
301 // Par consequent, les seules variables prises en compte sont de type
302 // "Real" et "Real3" et de dimension 1.
303 IMesh* mesh = m_mesh;
304 Integer nb_comp_node_data = 0;
305 Integer nb_comp_cell_data = 0;
306 Integer comp_node_data_size = 0;
307 Integer comp_cell_data_size = 0;
308 OStringStream ndata_size_stream, cdata_size_stream;
309 OStringStream ndata_name_stream, cdata_name_stream;
310 ndata_size_stream().precision(MAX_FLOAT_DIGIT);
311 ndata_name_stream().precision(MAX_FLOAT_DIGIT);
312 cdata_size_stream().precision(MAX_FLOAT_DIGIT);
313 cdata_name_stream().precision(MAX_FLOAT_DIGIT);
314
315 ndata_size_stream().flags(std::ios::scientific);
316 ndata_name_stream().flags(std::ios::scientific);
317 cdata_size_stream().flags(std::ios::scientific);
318 cdata_name_stream().flags(std::ios::scientific);
319
320 for(VariableList::Enumerator i(m_save_variables); ++i; ){
321 IVariable* var = *i;
322
323 if (var->dimension() == 1){
324 eDataType type = var->dataType();
325 eItemKind kind = var->itemKind();
326 String name = var->name();
327 if (type == DT_Real){
328 if (kind == IK_Node){
329 debug() << " Variable " << name
330 << " kind = IK_Node, type = DT_Real";
331 nb_comp_node_data++;
332 comp_node_data_size++;
333 ndata_size_stream() << " 1"; // 1 = taille du Real
334 ndata_name_stream() << name << ", Unknown" << '\n';
335 }
336 else if (kind == IK_Cell){
337 debug() << " Variable " << name
338 << " kind = IK_Cell, type = DT_Real";
339 nb_comp_cell_data++;
340 comp_cell_data_size++;
341 cdata_size_stream() << " 1"; // 1 = taille du Real1
342 cdata_name_stream() << name << ", Unknown" << '\n';
343 }
344 }
345 else if (type == DT_Real3){
346 if (kind == IK_Node){
347 debug() << " Variable " << name
348 << " kind = IK_Node, type = DT_Real3";
349 nb_comp_node_data++;
350 comp_node_data_size+=3;
351 ndata_size_stream() << " 3"; // 3 = taille du Real3
352 ndata_name_stream() << name << ", Unknown" << '\n';
353 }
354 else if (kind == IK_Cell){
355 debug() << " Variable " << name
356 << " kind = IK_Cell, type = DT_Real3";
357 nb_comp_cell_data++;
358 comp_cell_data_size+=3;
359 cdata_size_stream() << " 3"; // 3 = taille du Real3
360 cdata_name_stream() << name << ", Unknown" << '\n';
361 }
362 }
363 }
364 }
365
366 Integer nb_node = mesh->nbNode();
367 Integer nb_managed_cell = m_managed_cells.size();
368 ucd_file << nb_node << " "
369 << nb_managed_cell << " "
370 << comp_node_data_size << " "
371 << comp_cell_data_size << " 0" << '\n';
372
373 // ajout des coordonnees des noeuds
374 ConstArrayView<Real3> node_coords = mesh->toPrimaryMesh()->nodesCoordinates().asArray();
375 for( Integer i=0 ; i<nb_node ; i++){
376 const Real3 node_coord = node_coords[i];
377 ucd_file << i+1 << " "
378 << node_coord.x << " "
379 << node_coord.y << " "
380 << node_coord.z << '\n';
381 }
382
383 // ajout de la description des mailles
384 for( Integer iz=0 ; iz<nb_managed_cell ; ++iz ){
385 const Cell cell = m_managed_cells[iz];
386 Integer id = cell.localId();
387 ucd_file << id+1 << " 1 ";
388 Integer nb_cell_node=cell.nbNode();
389 switch(cell.type()){
390 case(IT_Vertex):
391 ucd_file << "pt";
392 ucd_file << " " << cell.node(0).localId()+1;
393 break;
394 case(IT_Line2):
395 ucd_file << "line";
396 for( Integer i=0 ; i<nb_cell_node ; i++)
397 ucd_file << " " << cell.node(i).localId()+1;
398 break;
399 case(IT_Triangle3):
400 ucd_file << "tri";
401 for( Integer i=0 ; i<nb_cell_node ; i++)
402 ucd_file << " " << cell.node(i).localId()+1;
403 break;
404 case(IT_Quad4):
405 ucd_file << "quad";
406 for( Integer i=0 ; i<nb_cell_node ; i++)
407 ucd_file << " " << cell.node(i).localId()+1;
408 break;
409 case(IT_Hexaedron8):
410 ucd_file << "hex";
411 for( Integer i=0 ; i<nb_cell_node ; i++)
412 ucd_file << " " << cell.node(code_hex[i]).localId()+1;
413 break;
414 case(IT_Pyramid5):
415 ucd_file << "pyr";
416 for( Integer i=0 ; i<nb_cell_node ; i++)
417 ucd_file << " " << cell.node(code_pyr[i]).localId()+1;
418 break;
419 case(IT_Pentagon5):
420 ucd_file << "prism";
421 for( Integer i=0 ; i<nb_cell_node ; i++)
422 ucd_file << " " << cell.node(code_prism[i]).localId()+1;
423 break;
424 case(IT_Tetraedron4):
425 ucd_file << "tet";
426 for( Integer i=0 ; i<nb_cell_node ; i++)
427 ucd_file << " " << cell.node(code_tet[i]).localId()+1;
428 break;
429 default:
430 // ce cas ne peut pas arriver car filtrage dans le constructeur
431 break;
432 }
433
434 ucd_file << '\n';
435 }
436
437 // ajout du nombre de donnees aux noeuds, de leur taille, de leur nom
438 // et des valeurs des variables
439 if (nb_comp_node_data){
440 ucd_file << nb_comp_node_data
441 << ndata_size_stream.str()
442 << '\n'
443 << ndata_name_stream.str();
444 for( Integer i=0 ; i<nb_node ; i++)
445 ucd_file << i+1 << m_node_streams[i]->str() << '\n';
446 }
447
448 // idem pour les mailles
449 if (nb_comp_cell_data){
450 ucd_file << nb_comp_cell_data
451 << cdata_size_stream.str()
452 << '\n'
453 << cdata_name_stream.str();
454 for( Integer i=0 ; i<nb_managed_cell ; i++){
455 const Cell& cell = m_managed_cells[i];
456 ucd_file << cell.localId()+1 << m_cell_streams[i]->str() << '\n';
457 }
458 }
459
460 OStringStream code_ostr;
461 code_ostr() << "U_";
462 code_ostr().fill('0');
463 code_ostr().width(m_max_digit);
464 code_ostr() << m_times.size()-1;
465 code_ostr() << '\0';
466 buf = m_base_directory.file(code_ostr.str());
467 std::ofstream code_file(buf.localstr());
468 code_file << m_sub_domain->commonVariables().globalIteration() << '\n'
469 << m_times[m_times.size()-1] << '\n'
470 << "3" << '\n' << "1" << '\n'
471 << "7" << '\n' << "Unknown" << '\n'
472 << comp_node_data_size << '\n' << comp_cell_data_size << '\n';
473 for( Integer i=0 ; i<comp_node_data_size ; i++)
474 code_file << "1"<< '\n';
475 for( Integer i=0 ; i<comp_cell_data_size ; i++)
476 code_file << "1"<< '\n';
477}
478
479/*---------------------------------------------------------------------------*/
480/*---------------------------------------------------------------------------*/
481
482/*---------------------------------------------------------------------------*/
483/*---------------------------------------------------------------------------*/
487class UCDPostProcessorService
488: public PostProcessorWriterBase
489{
490 public:
491 explicit UCDPostProcessorService(const ServiceBuildInfo& sbi)
492 : PostProcessorWriterBase(sbi), m_writer(nullptr) {}
493 IDataWriter* dataWriter() override { return m_writer; }
494 void notifyBeginWrite() override;
495 void notifyEndWrite() override;
496 void close() override {}
497 private:
498 DumpW* m_writer;
499};
500
501/*---------------------------------------------------------------------------*/
502/*---------------------------------------------------------------------------*/
503
504void UCDPostProcessorService::
505notifyBeginWrite()
506{
507 m_writer = new DumpWUCD(subDomain(),subDomain()->defaultMesh(),
508 baseDirectoryName(),times(),variables());
509}
510
511void UCDPostProcessorService::
512notifyEndWrite()
513{
514 delete m_writer;
515 m_writer = 0;
516}
517
518/*---------------------------------------------------------------------------*/
519/*---------------------------------------------------------------------------*/
520
521ARCANE_REGISTER_CASE_OPTIONS_NOAXL_FACTORY(UCDPostProcessorService,IPostProcessorWriter,UCDPostProcessor);
522
523ARCANE_REGISTER_SUB_DOMAIN_FACTORY(UCDPostProcessorService,IPostProcessorWriter,UCDPostProcessor);
524
525/*---------------------------------------------------------------------------*/
526/*---------------------------------------------------------------------------*/
527
528} // End namespace Arcane
529
530/*---------------------------------------------------------------------------*/
531/*---------------------------------------------------------------------------*/
ENUMERATE_CELL
#define ENUMERATE_CELL(name, group)
Enumérateur générique d'un groupe de mailles.
Definition ItemEnumerator.h:427
ARCANE_REGISTER_SUB_DOMAIN_FACTORY
#define ARCANE_REGISTER_SUB_DOMAIN_FACTORY(aclass, ainterface, aname)
Enregistre un service de fabrique pour la classe aclass.
Definition ServiceFactory.h:586
ARCANE_REGISTER_CASE_OPTIONS_NOAXL_FACTORY
#define ARCANE_REGISTER_CASE_OPTIONS_NOAXL_FACTORY(aclass, ainterface, aname)
Enregistre un service de fabrique pour la classe aclass.
Definition ServiceFactory.h:614
Arcane::Cell
Maille d'un maillage.
Definition Item.h:1178
Arcane::Directory
Classe gérant un répertoire.
Definition Directory.h:33
Arcane::Directory::file
virtual String file(const String &file_name) const
Retourne le chemin complet du fichier file_name dans le répertoire.
Definition Directory.cc:138
Arcane::Directory::createDirectory
virtual bool createDirectory() const
Créé le répertoire.
Definition Directory.cc:120
Arcane::DumpWUCD
Ecriture au format UCD.
Definition DumpWUCD.cc:69
Arcane::DumpWUCD::m_save_variables
VariableList m_save_variables
Liste des variables a exporter.
Definition DumpWUCD.cc:123
Arcane::DumpWUCD::m_cell_streams
UniqueArray< Ref< OStringStream > > m_cell_streams
Valeur des var. aux mailles.
Definition DumpWUCD.cc:125
Arcane::DumpWUCD::m_mesh
IMesh * m_mesh
Maillage.
Definition DumpWUCD.cc:120
Arcane::DumpWUCD::m_node_streams
UniqueArray< Ref< OStringStream > > m_node_streams
Valeur des var. aux noeuds.
Definition DumpWUCD.cc:126
Arcane::DumpWUCD::writeVal
void writeVal(IVariable &, ConstArrayView< Byte >) override
Ecriture pour la variable v du tableau a.
Definition DumpWUCD.cc:82
Arcane::DumpWUCD::m_times
RealUniqueArray m_times
Liste des instants de temps.
Definition DumpWUCD.cc:122
Arcane::DumpWUCD::m_base_directory
Directory m_base_directory
Nom du répertoire de stockage.
Definition DumpWUCD.cc:121
Arcane::DumpWUCD::m_managed_cells
UniqueArray< Cell > m_managed_cells
Liste des mailles gerees.
Definition DumpWUCD.cc:127
Arcane::DumpWUCD::beginWrite
void beginWrite() override
Creation du fichier UCD (nomme UCD_<no_iteration>) et de son entete. Cette entete contient :
Definition DumpWUCD.cc:270
Arcane::DumpWUCD::endWrite
void endWrite() override
Concatenation du flux contenant les donnees des mailles au fichier principal.
Definition DumpWUCD.cc:282
Arcane::DumpWUCD::setMetaData
void setMetaData(const String &meta_data) override
Positionne les infos des méta-données.
Definition DumpWUCD.cc:76
Arcane::DumpW
wrapper transformant des appels à l'interface IDataWriter en ex IDumpW
Definition DumpW.h:45
Arcane::IDataWriter
Interface d'écriture des données d'une variable.
Definition IDataWriter.h:49
Arcane::IMeshBase::nbCell
virtual Integer nbCell()=0
Nombre de mailles du maillage.
Arcane::IMeshBase::nbNode
virtual Integer nbNode()=0
Nombre de noeuds du maillage.
Arcane::IMeshBase::allCells
virtual CellGroup allCells()=0
Groupe de toutes les mailles.
Arcane::IMesh::toPrimaryMesh
virtual IPrimaryMesh * toPrimaryMesh()=0
Retourne l'instance sous la forme d'un IPrimaryMesh.
Arcane::IPostProcessorWriter
Interface d'un écrivain pour les informations de post-traitement.
Definition IPostProcessorWriter.h:58
Arcane::ISubDomain
Interface du gestionnaire d'un sous-domaine.
Definition ISubDomain.h:74
Arcane::ISubDomain::commonVariables
virtual const CommonVariables & commonVariables() const =0
Informations sur les variables standards.
Arcane::IVariable
Interface d'une variable.
Definition IVariable.h:54
Arcane::IVariable::itemKind
virtual eItemKind itemKind() const =0
Type des entités du maillage sur lequel repose la variable.
Arcane::IVariable::name
virtual String name() const =0
Nom de la variable.
Arcane::ItemWithNodes::node
Node node(Int32 i) const
i-ème noeud de l'entité
Definition Item.h:768
Arcane::ItemWithNodes::nbNode
Int32 nbNode() const
Nombre de noeuds de l'entité
Definition Item.h:765
Arcane::Item::localId
constexpr Int32 localId() const
Identifiant local de l'entité dans le sous-domaine du processeur.
Definition Item.h:210
Arcane::Item::uniqueId
ItemUniqueId uniqueId() const
Identifiant unique sur tous les domaines.
Definition Item.h:216
Arcane::Item::type
Int16 type() const
Type de l'entité
Definition Item.h:232
Arcane::LimaWrapper
Lecteur des fichiers de maillage via la bibliothèque LIMA.
Definition Lima.cc:120
Arcane::OStringStream
Flot de sortie lié à une String.
Definition OStringStream.h:36
Arcane::PostProcessorWriterBase
Classe de base d'un écrivain pour les informations de post-traitement.
Definition PostProcessorWriterBase.h:40
Arcane::PostProcessorWriterBase::times
virtual RealConstArrayView times()
Liste des temps sauvés.
Definition PostProcessorWriterBase.cc:144
Arcane::PostProcessorWriterBase::baseDirectoryName
virtual const String & baseDirectoryName()
Nom du répertoire de sortie des fichiers.
Definition PostProcessorWriterBase.cc:90
Arcane::PostProcessorWriterBase::variables
virtual VariableCollection variables()
Liste des variables à sauver.
Definition PostProcessorWriterBase.cc:153
Arcane::Real3
Classe gérant un vecteur de réel de dimension 3.
Definition Real3.h:132
Arcane::ServiceBuildInfo
Structure contenant les informations pour créer un service.
Definition ServiceBuildInfo.h:198
Arcane::UCDPostProcessorService
Post-traitement au format UCD.
Definition DumpWUCD.cc:489
Arcane::UCDPostProcessorService::notifyBeginWrite
void notifyBeginWrite() override
Notifie qu'une sortie va être effectuée avec les paramètres courants.
Definition DumpWUCD.cc:505
Arcane::UCDPostProcessorService::dataWriter
IDataWriter * dataWriter() override
Retourne l'écrivain associé à ce post-processeur.
Definition DumpWUCD.cc:493
Arcane::UCDPostProcessorService::close
void close() override
Ferme l'écrivain. Après fermeture, il ne peut plus être utilisé
Definition DumpWUCD.cc:496
Arcane::UCDPostProcessorService::notifyEndWrite
void notifyEndWrite() override
Notifie qu'une sortie vient d'être effectuée.
Definition DumpWUCD.cc:512
Arcane::VariableCollection
Collection de variables.
Definition VariableCollection.h:81
Arccore::AbstractArray::size
Integer size() const
Nombre d'éléments du vecteur.
Definition arccore/src/collections/arccore/collections/Array.h:421
Arccore::Array::add
void add(ConstReferenceType val)
Ajoute l'élément val à la fin du tableau.
Definition arccore/src/collections/arccore/collections/Array.h:1151
Arccore::ConstArrayView
Vue constante d'un tableau de type T.
Definition arccore/src/base/arccore/base/ArrayView.h:533
Arccore::String
Chaîne de caractères unicode.
Definition arccore/src/base/arccore/base/String.h:70
Arccore::String::localstr
const char * localstr() const
Retourne la conversion de l'instance dans l'encodage UTF-8.
Definition String.cc:227
Arccore::TraceAccessor::debug
TraceMessageDbg debug(Trace::eDebugLevel=Trace::Medium) const
Flot pour un message de debug.
Definition arccore/src/trace/arccore/trace/TraceAccessor.h:120
Arccore::TraceAccessor::info
TraceMessage info() const
Flot pour un message d'information.
Definition TraceAccessor.cc:101
Arccore::UniqueArray
Vecteur 1D de données avec sémantique par valeur (style STL).
Definition arccore/src/collections/arccore/collections/Array.h:1807
Arcane
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
Definition AcceleratorGlobal.h:36
Arcane::eItemKind
eItemKind
Genre d'entité de maillage.
Definition ArcaneTypes.h:153
Arcane::IK_Node
@ IK_Node
Entité de maillage de genre noeud.
Definition ArcaneTypes.h:154
Arcane::IK_Cell
@ IK_Cell
Entité de maillage de genre maille.
Definition ArcaneTypes.h:157
Arcane::eDataType
eDataType
Type d'une donnée.
Definition DataTypes.h:39
Arcane::DT_Real3
@ DT_Real3
Donnée de type vecteur 3.
Definition DataTypes.h:47
Arcane::DT_Real
@ DT_Real
Donnée de type réel.
Definition DataTypes.h:41
Arccore::Integer
Int32 Integer
Type représentant un entier.
Definition ArccoreGlobal.h:240
Arccore::makeRef
auto makeRef(InstanceType *t) -> Ref< InstanceType >
Créé une référence sur un pointeur.
Definition arccore/src/base/arccore/base/Ref.h:356