Arcane  v3.14.10.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
Hdf5VariableInfoBase.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/* Hdf5ItemVariableInfo.cc (C) 2000-2023 */
9/* */
10/* Lecture de variables au format HDF5. */
11/*---------------------------------------------------------------------------*/
12/*---------------------------------------------------------------------------*/
13
14#include "arcane/utils/ITraceMng.h"
15#include "arcane/utils/StringBuilder.h"
16#include "arcane/utils/HashTableMap.h"
17#include "arcane/utils/NotImplementedException.h"
18#include "arcane/utils/NotSupportedException.h"
19#include "arcane/utils/ArgumentException.h"
20
21#include "arcane/hdf5/Hdf5VariableInfoBase.h"
22
23#include "arcane/core/MeshVariable.h"
24#include "arcane/core/IItemFamily.h"
25#include "arcane/core/IMesh.h"
26#include "arcane/core/IMeshSubMeshTransition.h"
27#include "arcane/core/IVariable.h"
28#include "arcane/core/IVariableMng.h"
29#include "arcane/core/IParallelMng.h"
30
31#include <typeinfo>
32
33/*---------------------------------------------------------------------------*/
34/*---------------------------------------------------------------------------*/
35
36namespace Arcane
37{
38
39/*---------------------------------------------------------------------------*/
40/*---------------------------------------------------------------------------*/
41
42template<typename VariableType,typename DataType>
43class Hdf5ItemVariableInfo
44: public Hdf5VariableInfoBase
45{
46 public:
47 Hdf5ItemVariableInfo(IMesh* mesh,IVariable* v);
48 public:
49 VariableType& trueVariable() { return m_variable; }
50 virtual IVariable* variable() const { return m_variable.variable(); }
51 public:
52 virtual void readVariable(Hdf5Utils::HFile& hfile,const String& filename,
53 Hdf5Utils::StandardTypes& st,const String& ids_hpath,IData* data);
54 virtual void writeVariable(Hdf5Utils::HFile& hfile,Hdf5Utils::StandardTypes& st);
55
56 private:
57 void _readStandardArray(Array<DataType>& buffer,Array<Int64>& unique_ids,const String& ids_hpath,
58 hid_t file_id,Hdf5Utils::StandardTypes& st);
59 void _writeStandardArray(Array<DataType>& buffer,hid_t file_id,Hdf5Utils::StandardTypes& st);
60 private:
61 VariableType m_variable;
62};
63
64/*---------------------------------------------------------------------------*/
65/*---------------------------------------------------------------------------*/
66
67template<typename VariableType,typename DataType>
68class Hdf5ScalarVariableInfo
69: public Hdf5VariableInfoBase
70{
71 public:
72 Hdf5ScalarVariableInfo(IVariable* v);
73 public:
74 VariableType& trueVariable() { return m_variable; }
75 virtual IVariable* variable() const { return m_variable.variable(); }
76 public:
77 virtual void readVariable(Hdf5Utils::HFile& hfile,const String& filename,
78 Hdf5Utils::StandardTypes& st,const String& ids_hpath,
79 IData* data);
80 virtual void writeVariable(Hdf5Utils::HFile& hfile,Hdf5Utils::StandardTypes& st);
81
82 private:
83 void _readStandardArray(Array<DataType>& buffer,
84 hid_t file_id,Hdf5Utils::StandardTypes& st);
85 void _writeStandardArray(Array<DataType>& buffer,hid_t file_id,Hdf5Utils::StandardTypes& st);
86 private:
87 VariableType m_variable;
88};
89
90/*---------------------------------------------------------------------------*/
91/*---------------------------------------------------------------------------*/
92
93Hdf5VariableInfoBase* Hdf5VariableInfoBase::
94create(IMesh* mesh,const String& name,const String& family_name)
95{
96 IItemFamily* family = mesh->findItemFamily(family_name,true);
97 IVariable* var = family->findVariable(name,true);
98 return Hdf5VariableInfoBase::create(var);
99}
100
101/*---------------------------------------------------------------------------*/
102/*---------------------------------------------------------------------------*/
103
104Hdf5VariableInfoBase* Hdf5VariableInfoBase::
105create(IVariable* var)
106{
107 _checkValidVariable(var);
108 Hdf5VariableInfoBase* var_info = 0;
109 IItemFamily* item_family = var->itemFamily();
110 if (item_family){
111 IMesh* mesh = item_family->mesh();
112 if (var->isPartial()){
113 switch(var->dataType()){
114 case DT_Real:
115 var_info = new Hdf5ItemVariableInfo<PartialVariableItemReal,Real>(mesh,var);
116 break;
117 case DT_Real2:
118 var_info = new Hdf5ItemVariableInfo<PartialVariableItemReal2,Real2>(mesh,var);
119 break;
120 case DT_Real2x2:
121 var_info = new Hdf5ItemVariableInfo<PartialVariableItemReal2x2,Real2x2>(mesh,var);
122 break;
123 case DT_Real3:
124 var_info = new Hdf5ItemVariableInfo<PartialVariableItemReal3,Real3>(mesh,var);
125 break;
126 case DT_Real3x3:
127 var_info = new Hdf5ItemVariableInfo<PartialVariableItemReal3x3,Real3x3>(mesh,var);
128 break;
129 case DT_Byte:
130 var_info = new Hdf5ItemVariableInfo<PartialVariableItemByte,Byte>(mesh,var);
131 break;
132 case DT_Int32:
133 var_info = new Hdf5ItemVariableInfo<PartialVariableItemInt32,Int32>(mesh,var);
134 break;
135 case DT_Int64:
136 var_info = new Hdf5ItemVariableInfo<PartialVariableItemInt64,Int64>(mesh,var);
137 break;
138 default:
139 throw FatalErrorException(A_FUNCINFO,"Bad variable type");
140 break;
141 }
142 }
143 else{
144 switch(var->dataType()){
145 case DT_Real:
146 var_info = new Hdf5ItemVariableInfo<VariableItemReal,Real>(mesh,var);
147 break;
148 case DT_Real2:
149 var_info = new Hdf5ItemVariableInfo<VariableItemReal2,Real2>(mesh,var);
150 break;
151 case DT_Real2x2:
152 var_info = new Hdf5ItemVariableInfo<VariableItemReal2x2,Real2x2>(mesh,var);
153 break;
154 case DT_Real3:
155 var_info = new Hdf5ItemVariableInfo<VariableItemReal3,Real3>(mesh,var);
156 break;
157 case DT_Real3x3:
158 var_info = new Hdf5ItemVariableInfo<VariableItemReal3x3,Real3x3>(mesh,var);
159 break;
160 case DT_Byte:
161 var_info = new Hdf5ItemVariableInfo<VariableItemByte,Byte>(mesh,var);
162 break;
163 case DT_Int32:
164 var_info = new Hdf5ItemVariableInfo<VariableItemInt32,Int32>(mesh,var);
165 break;
166 case DT_Int64:
167 var_info = new Hdf5ItemVariableInfo<VariableItemInt64,Int64>(mesh,var);
168 break;
169 default:
170 throw FatalErrorException(A_FUNCINFO,"Bad variable type");
171 break;
172 }
173 }
174 }
175 else{
176 if (var->dimension()==0){
177 switch(var->dataType()){
178 case DT_Real:
179 var_info = new Hdf5ScalarVariableInfo<VariableScalarReal,Real>(var);
180 break;
181 case DT_Real2:
182 var_info = new Hdf5ScalarVariableInfo<VariableScalarReal2,Real2>(var);
183 break;
184 case DT_Real2x2:
185 var_info = new Hdf5ScalarVariableInfo<VariableScalarReal2x2,Real2x2>(var);
186 break;
187 case DT_Real3:
188 var_info = new Hdf5ScalarVariableInfo<VariableScalarReal3,Real3>(var);
189 break;
190 case DT_Real3x3:
191 var_info = new Hdf5ScalarVariableInfo<VariableScalarReal3x3,Real3x3>(var);
192 break;
193 case DT_Byte:
194 var_info = new Hdf5ScalarVariableInfo<VariableScalarByte,Byte>(var);
195 break;
196 case DT_Int32:
197 var_info = new Hdf5ScalarVariableInfo<VariableScalarInt32,Int32>(var);
198 break;
199 case DT_Int64:
200 var_info = new Hdf5ScalarVariableInfo<VariableScalarInt64,Int64>(var);
201 break;
202 default:
203 throw FatalErrorException(A_FUNCINFO,"Bad variable type");
204 break;
205 }
206 }
207 }
208 if (!var_info)
209 throw NotSupportedException(A_FUNCINFO,
210 String::format("IData for variable '{0}'",var->fullName()));
211 return var_info;
212}
213
214/*---------------------------------------------------------------------------*/
215/*---------------------------------------------------------------------------*/
216
217void Hdf5VariableInfoBase::
218_checkValidVariable(IVariable* var)
219{
220 IItemFamily* item_family = var->itemFamily();
221 if (item_family){
222 if (var->dimension()==1)
223 return;
224 }
225 else{
226 if (var->dimension()==0)
227 return;
228 }
229
230 ARCANE_FATAL("Bad variable '{0}'. Variable has to be an item variable and have dimension"
231 "'1' or be a scalar variable",var->fullName());
232}
233
234/*---------------------------------------------------------------------------*/
235/*---------------------------------------------------------------------------*/
236
237void Hdf5VariableInfoBase::
238writeGroup(Hdf5Utils::HFile& hfile,Hdf5Utils::StandardTypes& st,
239 const String& hdf_path,Integer save_type)
240{
241 IVariable* var = variable();
242 ItemGroup group = var->itemGroup();
243 IParallelMng* pm = group.mesh()->parallelMng();
244 ItemGroup enumerate_group = group.own();
245 Integer nb_item = enumerate_group.size();
246 ITraceMng* tm = pm->traceMng();
247
248 // Pour l'instant la méthode parallèle créé un tampon
249 // du nombre total d'éléments du tableau
251 Int64UniqueArray unique_ids(nb_item);
252 {
253 Integer index = 0;
254 ENUMERATE_ITEM(iitem,enumerate_group){
255 unique_ids[index] = (*iitem).uniqueId();
256 ++index;
257 }
258 }
259
260 if (save_type & SAVE_IDS){
261 Hdf5Utils::StandardArrayT<Int64> ids_writer(hfile.id(),hdf_path+"_Ids");
262 ids_writer.parallelWrite(pm,st,unique_ids,unique_ids);
263 }
264
265 // Pour l'instant, on ne peut sauver que des tableaux 2D dont le nombre
266 // d'éléments dans la 2ème dimension est identique. Cela pose problème
267 // si toutes les entités n'ont pas le même nombre de noeuds. Pour
268 // éviter ce problème, on calcule le nombre max de noeud possible et on
269 // utilise cette valeur. Pour les entités qui ont moins de noeuds, on
270 // ajoute comme coordonnées des NaN. Cela n'est pas optimum notamment
271 // si une seule entité a beaucoup plus de noeuds que les autres mais
272 // cela fonctionne dans tous les cas.
273 if (save_type & SAVE_COORDS){
274 IMesh* mesh = enumerate_group.mesh();
275 VariableNodeReal3& nodes_coords(mesh->toPrimaryMesh()->nodesCoordinates());
276 eItemKind item_kind = enumerate_group.itemKind();
277 if (item_kind==IK_Edge || item_kind==IK_Face || item_kind==IK_Cell){
278 Integer index = 0;
279 Real3UniqueArray coords;
280 Real3UniqueArray centers;
281 Integer max_nb_node = 0;
282 const Real nan_value = std::numeric_limits<Real>::quiet_NaN();
283 const Real3 real3_nan = Real3(nan_value,nan_value,nan_value);
284 {
285 ENUMERATE_ITEMWITHNODES(iitem,enumerate_group){
286 ItemWithNodes item = (*iitem).toItemWithNodes();
287 Integer nb_node = item.nbNode();
288 if (nb_node>max_nb_node)
289 max_nb_node = nb_node;
290 }
291 max_nb_node = pm->reduce(Parallel::ReduceMax,max_nb_node);
292 }
293 Int32UniqueArray items_type(nb_item);
294 ENUMERATE_ITEMWITHNODES(iitem,enumerate_group){
295 ItemWithNodes item = (*iitem).toItemWithNodes();
296 Integer nb_node = item.nbNode();
297 Real3 item_center;
298 for( NodeLocalId inode : item.nodeIds() ){
299 coords.add(nodes_coords[inode]);
300 item_center += nodes_coords[inode];
301 }
302 item_center /= nb_node;
303 // Ajoute des NaN pour les coordonnées restantes
304 for( Integer k=nb_node; k<max_nb_node; ++k )
305 coords.add(real3_nan);
306 centers.add(item_center);
307 items_type[index] = item.typeInfo()->typeId();
308 ++index;
309 }
310 Hdf5Utils::StandardArrayT<Real3> coords_writer(hfile.id(),hdf_path+"_Coords");
311 coords_writer.parallelWrite(pm,st,coords,unique_ids);
312 Hdf5Utils::StandardArrayT<Real3> centers_writer(hfile.id(),hdf_path+"_Center");
313 centers_writer.parallelWrite(pm,st,centers,unique_ids);
314 Hdf5Utils::StandardArrayT<Int32> types_writer(hfile.id(),hdf_path+"_Types");
315 types_writer.parallelWrite(pm,st,items_type,unique_ids);
316 }
317 else if (item_kind==IK_Node){
318 Real3UniqueArray coords;
319 ENUMERATE_NODE(iitem,enumerate_group){
320 coords.add(nodes_coords[iitem]);
321 }
322 Hdf5Utils::StandardArrayT<Real3> coords_writer(hfile.id(),hdf_path+"_Center");
323 coords_writer.parallelWrite(pm,st,coords,unique_ids);
324 }
325 else
326 tm->pwarning() << "Can not save coordinates for family name="
327 << enumerate_group.itemFamily()->name();
328 }
329
330}
331
332/*---------------------------------------------------------------------------*/
333/*---------------------------------------------------------------------------*/
334
335void Hdf5VariableInfoBase::
336readGroupInfo(Hdf5Utils::HFile& hfile,Hdf5Utils::StandardTypes& st,
337 const String& hdf_path,Int64Array& uids,Real3Array& centers)
338{
339 IVariable* var = variable();
340 ItemGroup group = var->itemGroup();
341 IParallelMng* pm = group.mesh()->parallelMng();
342 ItemGroup enumerate_group = group;
343 ITraceMng* tm = pm->traceMng();
344 bool is_master = pm->isMasterIO();
345
346 // Lit les unique ids sauvegardés
347 Int64UniqueArray dummy_uids;
348 Int64UniqueArray saved_unique_ids;
349 Hdf5Utils::StandardArrayT<Int64> ids_reader(hfile.id(),hdf_path+"_Ids");
350 Integer nb_old_item = 0;
351 if (is_master){
352 ids_reader.readDim();
353 nb_old_item = arcaneCheckArraySize(ids_reader.dimensions()[0]);
354 tm->info() << "NB_OLD_ITEM nb=" << nb_old_item;
355 saved_unique_ids.resize(nb_old_item);
356 dummy_uids.resize(nb_old_item);
357 }
358 ids_reader.parallelRead(pm,st,saved_unique_ids,dummy_uids);
359
360 Real3UniqueArray saved_centers(nb_old_item);
361 Hdf5Utils::StandardArrayT<Real3> centers_reader(hfile.id(),hdf_path+"_Center");
362 if (is_master)
363 centers_reader.readDim();
364 centers_reader.parallelRead(pm,st,saved_centers,dummy_uids);
365 tm->info() << "READ SAVED CENTERS nb=" << saved_centers.size();
366
367 uids.copy(saved_unique_ids);
368 centers.copy(saved_centers);
369}
370
371/*---------------------------------------------------------------------------*/
372/*---------------------------------------------------------------------------*/
373
374/*---------------------------------------------------------------------------*/
375/*---------------------------------------------------------------------------*/
376
377template<typename VariableType,typename DataType>
378Hdf5ItemVariableInfo<VariableType,DataType>::
379Hdf5ItemVariableInfo(IMesh* mesh,IVariable* v)
380: Hdf5VariableInfoBase()
381, m_variable(v)
382{
383 ARCANE_UNUSED(mesh);
384}
385
386/*---------------------------------------------------------------------------*/
387/*---------------------------------------------------------------------------*/
388
389template<typename VariableType,typename DataType> void
390Hdf5ItemVariableInfo<VariableType,DataType>::
391readVariable(Hdf5Utils::HFile& hfile,const String& filename,
392 Hdf5Utils::StandardTypes& st,const String& ids_hpath,IData* var_data)
393{
394 ARCANE_UNUSED(ids_hpath);
395
396 if (!var_data)
397 var_data = variable()->data();
398 if (!var_data)
399 throw ArgumentException(A_FUNCINFO,"Null var_data");
400 UniqueArray<DataType> buffer;
401 IArrayDataT<DataType>* data_array = dynamic_cast<IArrayDataT<DataType>*>(var_data);
402 if (!data_array){
403 const char* n = typeid(var_data).name();
404 throw FatalErrorException(A_FUNCINFO,String::format("Bad type for IData '{0}'",n));
405 }
406 ArrayView<DataType> var_value = data_array->view();
407 IVariable* var = m_variable.variable();
408 IVariableMng* vm = var->variableMng();
409 ITraceMng* tm = vm->traceMng();
410 IParallelMng* pm = vm->parallelMng();
411 bool is_master = pm->isMasterIO();
412 //Integer master_rank = pm->masterIORank();
413 if (is_master){
414 if (hfile.id()<0)
415 hfile.openRead(filename);
416 }
417
418 Int64UniqueArray unique_ids;
419 _readStandardArray(buffer,unique_ids,ids_hpath,hfile.id(),st);
420
421 Integer buf_size = buffer.size();
422 //ArrayView<DataType> var_value = m_variable.asArray();
423 Integer nb_var_value = var_value.size();
424 if (var->isPartial()){
425 // Dans le cas d'une variables partielle, il faut d'abord
426 // mettre dans une table de hashage la valeur pour chaque uid,
427 // puis parcourir le groupe de la variable et remplir
428 // la valeur pour chaque uid.
429 HashTableMapT<Int64,DataType> values_from_uid(buf_size,true);
430 for( Integer z=0; z<buf_size; ++z ){
431 values_from_uid.add(unique_ids[z],buffer[z]);
432 }
433 ItemGroup var_group = m_variable.itemGroup();
434 ENUMERATE_ITEM(iitem,var_group){
435 Item item = *iitem;
436 Int64 uid = item.uniqueId();
437 if (m_correspondance_functor){
438 uid = m_correspondance_functor->getOldUniqueId(uid,iitem.index());
439 }
440 typename HashTableMapT<Int64,DataType>::Data* data = values_from_uid.lookup(uid);
441 if (!data)
442 throw FatalErrorException(A_FUNCINFO,
443 String::format("Can not find item uid='{0}' reading variable '{1}'",
444 uid,var->fullName()));
445 DataType value = data->value();
446 var_value[iitem.index()] = value;
447 }
448 }
449 else{
450 Int32UniqueArray local_ids(buf_size);
451 var->itemFamily()->itemsUniqueIdToLocalId(local_ids,unique_ids,false);
452 for( Integer z=0; z<buf_size; ++z ){
453 Integer lid = local_ids[z];
454 if (lid==NULL_ITEM_LOCAL_ID)
455 continue;
456 if (lid>nb_var_value)
457 throw FatalErrorException(A_FUNCINFO,String::format("Bad item index '{0}' max={1}",lid,nb_var_value));
458 var_value[lid] = buffer[z];
459 }
460 }
461 tm->info(4) << "End of read for variable '" << var->fullName() << "'";
462}
463
464/*---------------------------------------------------------------------------*/
465/*---------------------------------------------------------------------------*/
466
467template<typename VariableType,typename DataType> void
468Hdf5ItemVariableInfo<VariableType,DataType>::
469_readStandardArray(Array<DataType>& buffer,Int64Array& unique_ids,
470 const String& ids_hpath,hid_t file_id,
471 Hdf5Utils::StandardTypes& st)
472{
473 ARCANE_UNUSED(ids_hpath);
474
475 IVariable* var = m_variable.variable();
476 IVariableMng* vm = var->variableMng();
477 ITraceMng* tm = vm->traceMng();
478 IParallelMng* pm = vm->parallelMng();
479 bool is_master = pm->isMasterIO();
480
481 Hdf5Utils::StandardArrayT<DataType> values(file_id,path());
482
483 if (is_master){
484 if (!ids_hpath.null())
485 values.setIdsPath(ids_hpath);
486 values.readDim();
487 Int64ConstArrayView dims(values.dimensions());
488 Integer nb_dim = dims.size();
489 if (nb_dim!=1)
490 tm->fatal() << "Only one-dimension array are allowed "
491 << " dim=" << nb_dim << " var_name=" << var->fullName() << " path=" << path();
492 Integer nb_item = arcaneCheckArraySize(dims[0]);
493 tm->info(4) << "NB_ITEM: nb_item=" << nb_item;
494 buffer.resize(nb_item);
495 unique_ids.resize(nb_item);
496 }
497 values.parallelRead(pm,st,buffer,unique_ids);
498#if 0
499 {
500 Integer index=0;
501 Integer nb_item = buffer.size();
502 for( Integer i=0; i<nb_item; ++i ){
503 ++index;
504 tm->info() << " VAR_VAL i=" << i << " value=" << buffer[i] << " uid=" << unique_ids[i];
505 if (index>20)
506 break;
507 }
508 }
509#endif
510}
511
512/*---------------------------------------------------------------------------*/
513/*---------------------------------------------------------------------------*/
514
515template<typename VariableType,typename DataType> void
516Hdf5ItemVariableInfo<VariableType,DataType>::
517_writeStandardArray(Array<DataType>& buffer,hid_t file_id,Hdf5Utils::StandardTypes& st)
518{
519 Hdf5Utils::StandardArrayT<DataType> values(file_id,path());
520 //ITraceMng* tm = m_mesh->traceMng();
521 //tm->info() << "WRITE STANDARD ARRAY N=" << buffer.size();
522 values.write(st,buffer);
523}
524
525/*---------------------------------------------------------------------------*/
526/*---------------------------------------------------------------------------*/
527
528template<typename VariableType,typename DataType> void
529Hdf5ItemVariableInfo<VariableType,DataType>::
530writeVariable(Hdf5Utils::HFile& hfile,Hdf5Utils::StandardTypes& st)
531{
532 IVariable* var = m_variable.variable();
533 IVariableMng* vm = var->variableMng();
534 IParallelMng* pm = vm->parallelMng();
535 ITraceMng* tm = vm->traceMng();
536
537 ItemGroup group = m_variable.itemGroup();
538 ItemGroup enumerate_group = group.own();
539 if (var->isPartial())
540 enumerate_group = group;
541
542 Integer nb_item = enumerate_group.size();
543
544 UniqueArray<DataType> values(nb_item);
545 Int64UniqueArray unique_ids(nb_item);
546 tm->info(4) << "WRITE VARIABLE name=" << m_variable.name()
547 << " is_partial=" << m_variable.variable()->isPartial();
548
549 {
550 Integer index = 0;
551 ENUMERATE_ITEM(iitem,enumerate_group){
552 if (iitem->isOwn()){
553 values[index] = m_variable[iitem];
554 unique_ids[index] = iitem->uniqueId();
555 //tm->info() << "WRITE uid=" << iitem->uniqueId()
556 // << " value=" << m_variable[iitem];
557 ++index;
558 }
559 }
560 values.resize(index);
561 unique_ids.resize(index);
562 }
563 // Pour l'instant la méthode parallèle créé un tampon
564 // du nombre total d'éléments du tableau
566 {
567 Hdf5Utils::StandardArrayT<DataType> values_writer(hfile.id(),path());
568 values_writer.parallelWrite(pm,st,values,unique_ids);
569 }
570}
571
572/*---------------------------------------------------------------------------*/
573/*---------------------------------------------------------------------------*/
574
575/*---------------------------------------------------------------------------*/
576/*---------------------------------------------------------------------------*/
577
578template<typename VariableType,typename DataType>
579Hdf5ScalarVariableInfo<VariableType,DataType>::
580Hdf5ScalarVariableInfo(IVariable* v)
581: Hdf5VariableInfoBase()
582, m_variable(v)
583{
584}
585
586/*---------------------------------------------------------------------------*/
587/*---------------------------------------------------------------------------*/
588
589template<typename VariableType,typename DataType> void
590Hdf5ScalarVariableInfo<VariableType,DataType>::
591readVariable(Hdf5Utils::HFile& hfile,const String& filename,
592 Hdf5Utils::StandardTypes& st,const String& ids_hpath,IData* data)
593{
594 ARCANE_UNUSED(ids_hpath);
595
596 UniqueArray<DataType> buffer;
597 IVariable* var = m_variable.variable();
598 IVariableMng* vm = var->variableMng();
599 ITraceMng* tm = vm->traceMng();
600 IParallelMng* pm = vm->parallelMng();
601 bool is_master = pm->isMasterIO();
602 //Integer master_rank = pm->masterIORank();
603 if (is_master){
604 if (hfile.id()<0)
605 hfile.openRead(filename);
606 }
607
608 Int64UniqueArray unique_ids;
609 _readStandardArray(buffer,hfile.id(),st);
610
611 Integer buf_size = buffer.size();
612 if (!data)
613 data = m_variable.variable()->data();
614 IArrayDataT<DataType>* true_data = dynamic_cast<IArrayDataT<DataType>*>(data);
615 if (!true_data)
616 throw FatalErrorException("Can not convert IData to IArrayDataT");
617 ArrayView<DataType> var_value = m_variable.asArray();
618 for( Integer z=0; z<buf_size; ++z )
619 var_value[z] = buffer[z];
620 tm->info(4) << "End of read for variable '" << var->fullName() << "'";
621}
622
623/*---------------------------------------------------------------------------*/
624/*---------------------------------------------------------------------------*/
625
626template<typename VariableType,typename DataType> void
627Hdf5ScalarVariableInfo<VariableType,DataType>::
628_readStandardArray(Array<DataType>& buffer,hid_t file_id,Hdf5Utils::StandardTypes& st)
629{
630 IVariable* var = m_variable.variable();
631 IVariableMng* vm = var->variableMng();
632 ITraceMng* tm = vm->traceMng();
633 IParallelMng* pm = vm->parallelMng();
634 bool is_master = pm->isMasterIO();
635
636 Hdf5Utils::StandardArrayT<DataType> values(file_id,path());
637
638 if (is_master){
639 values.readDim();
640 Int64ConstArrayView dims(values.dimensions());
641 Integer nb_dim = dims.size();
642 if (nb_dim!=1)
643 tm->fatal() << "Only one-dimension array are allowed "
644 << " dim=" << nb_dim << " var_name=" << var->fullName() << " path=" << path();
645 Integer nb_item = arcaneCheckArraySize(dims[0]);
646 tm->info(4) << "NB_ITEM: nb_item=" << nb_item;
647 buffer.resize(nb_item);
648 }
649 values.read(st,buffer);
650#if 0
651 {
652 Integer index=0;
653 Integer nb_item = buffer.size();
654 for( Integer i=0; i<nb_item; ++i ){
655 ++index;
656 tm->info() << " VAR_VAL i=" << i << " value=" << buffer[i];
657 if (index>20)
658 break;
659 }
660 }
661#endif
662}
663
664/*---------------------------------------------------------------------------*/
665/*---------------------------------------------------------------------------*/
666
667template<typename VariableType,typename DataType> void
668Hdf5ScalarVariableInfo<VariableType,DataType>::
669_writeStandardArray(Array<DataType>& buffer,hid_t file_id,Hdf5Utils::StandardTypes& st)
670{
671 Hdf5Utils::StandardArrayT<DataType> values(file_id,path());
672 values.write(st,buffer);
673}
674
675/*---------------------------------------------------------------------------*/
676/*---------------------------------------------------------------------------*/
677
678template<typename VariableType,typename DataType> void
679Hdf5ScalarVariableInfo<VariableType,DataType>::
680writeVariable(Hdf5Utils::HFile& hfile,Hdf5Utils::StandardTypes& st)
681{
682 IVariable* var = m_variable.variable();
683 IVariableMng* vm = var->variableMng();
684 IParallelMng* pm = vm->parallelMng();
685 ITraceMng* tm = vm->traceMng();
686 bool is_master = pm->isMasterIO();
687
688 ConstArrayView<DataType> var_values = m_variable.asArray();
689 Integer size = var_values.size();
690 UniqueArray<DataType> values(size);
691 for( Integer i=0; i<size; ++i )
692 values[i] = var_values[i];
693
694 // Comme il s'agit d'une variable scalaire, on considère que tous
695 // les processeurs ont la même valeur. Donc seul le processeur
696 // maitre écrit.
697 if (is_master){
698 //{
699 Int64UniqueArray unique_ids;
700 Hdf5Utils::StandardArrayT<DataType> values_writer(hfile.id(),path());
701 tm->info(4) << "WRITE SCALAR VARIABLE name=" << m_variable.variable()->fullName();
702 values_writer.write(st,values);
703 //values_writer.parallelWrite(pm,st,values,unique_ids);
704 }
705}
706
707/*---------------------------------------------------------------------------*/
708/*---------------------------------------------------------------------------*/
709
710} // End namespace Arcane
711
712/*---------------------------------------------------------------------------*/
713/*---------------------------------------------------------------------------*/
ARCANE_FATAL
#define ARCANE_FATAL(...)
Macro envoyant une exception FatalErrorException.
Definition ArcaneGlobal.h:809
ENUMERATE_ITEM
#define ENUMERATE_ITEM(name, group)
Enumérateur générique d'un groupe de noeuds.
Definition ItemEnumerator.h:413
ENUMERATE_NODE
#define ENUMERATE_NODE(name, group)
Enumérateur générique d'un groupe de noeuds.
Definition ItemEnumerator.h:418
Arcane::Array
Tableau d'items de types quelconques.
Definition AnyItemArray.h:55
Arcane::Hdf5ItemVariableInfo::writeVariable
virtual void writeVariable(Hdf5Utils::HFile &hfile, Hdf5Utils::StandardTypes &st)
Definition Hdf5VariableInfoBase.cc:530
Arcane::Hdf5Utils::HFile
Encapsule un hid_t pour un fichier.
Definition hdf5/Hdf5Utils.h:210
Arcane::Hdf5Utils::StandardArrayT
Encapsule un dataset simple d'un fichier HDF5 qui représente un tableau.
Definition hdf5/Hdf5Utils.h:777
Arcane::Hdf5Utils::StandardTypes
Définition des types standards Arcane pour hdf5.
Definition hdf5/Hdf5Utils.h:562
Arcane::Hdf5VariableInfoBase
Classe de base pour lire ou écrire une variables.
Definition hdf5/Hdf5VariableInfoBase.h:38
Arcane::Hdf5VariableInfoBase::writeGroup
void writeGroup(Hdf5Utils::HFile &hfile, Hdf5Utils::StandardTypes &st, const String &hdf_path, Integer save_type)
Definition Hdf5VariableInfoBase.cc:238
Arcane::IData
Interface d'une donnée.
Definition IData.h:33
Arcane::IItemFamily
Interface d'une famille d'entités.
Definition IItemFamily.h:111
Arcane::IItemFamily::findVariable
virtual IVariable * findVariable(const String &name, bool throw_exception=false)=0
Recherche la variable de nom name associée à cette famille.
Arcane::IMeshBase::findItemFamily
virtual IItemFamily * findItemFamily(eItemKind ik, const String &name, bool create_if_needed=false, bool register_modifier_if_created=false)=0
Retourne la famille de nom name.
Arcane::IMesh::parallelMng
virtual IParallelMng * parallelMng()=0
Gestionnaire de parallèlisme.
Arcane::IMesh::toPrimaryMesh
virtual IPrimaryMesh * toPrimaryMesh()=0
Retourne l'instance sous la forme d'un IPrimaryMesh.
Arcane::IParallelMng
Interface du gestionnaire de parallélisme pour un sous-domaine.
Definition IParallelMng.h:52
Arcane::IParallelMng::traceMng
virtual ITraceMng * traceMng() const =0
Gestionnaire de traces.
Arcane::IParallelMng::isMasterIO
virtual bool isMasterIO() const =0
true si l'instance est un gestionnaire maître des entrées/sorties.
Arcane::IParallelMng::reduce
virtual char reduce(eReduceType rt, char v)=0
Effectue la réduction de type rt sur le réel v et retourne la valeur.
Arcane::IVariableMng
Interface du gestionnaire de variables.
Definition IVariableMng.h:57
Arcane::IVariable
Interface d'une variable.
Definition IVariable.h:54
Arcane::IVariable::fullName
virtual String fullName() const =0
Nom complet de la variable (avec le préfixe de la famille)
Arcane::IVariable::dimension
virtual Integer dimension() const =0
Dimension de la variable.
Arcane::IVariable::variableMng
virtual IVariableMng * variableMng() const =0
Gestionnaire de variable associé à la variable.
Arcane::ItemGroup
Groupe d'entités de maillage.
Definition ItemGroup.h:49
Arcane::ItemGroup::mesh
IMesh * mesh() const
Maillage auquel appartient ce groupe (0 pour le group nul)
Definition ItemGroup.h:126
Arcane::ItemGroup::own
ItemGroup own() const
Groupe équivalent à celui-ci mais contenant uniquement les éléments propres au sous-domaine.
Definition ItemGroup.cc:189
Arcane::ItemTypeInfo::typeId
Int16 typeId() const
Numéro du type.
Definition ItemTypeInfo.h:103
Arcane::ItemWithNodes
Elément de maillage s'appuyant sur des noeuds (Edge,Face,Cell).
Definition Item.h:714
Arcane::ItemWithNodes::nbNode
Int32 nbNode() const
Nombre de noeuds de l'entité
Definition Item.h:765
Arcane::ItemWithNodes::nodeIds
NodeLocalIdView nodeIds() const
Liste des noeuds de l'entité
Definition Item.h:774
Arcane::Item::typeInfo
const ItemTypeInfo * typeInfo() const
Infos sur le type de l'entité.
Definition Item.h:377
Arcane::Item::toItemWithNodes
ItemWithNodes toItemWithNodes() const
Converti l'entité en le genre ItemWithNodes.
Definition Item.h:1626
Arcane::LimaWrapper
Lecteur des fichiers de maillage via la bibliothèque LIMA.
Definition Lima.cc:120
Arcane::Real3
Classe gérant un vecteur de réel de dimension 3.
Definition Real3.h:132
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::FatalErrorException
Exception lorsqu'une erreur fatale est survenue.
Definition arccore/src/base/arccore/base/FatalErrorException.h:32
Arccore::ITraceMng
Interface du gestionnaire de traces.
Definition arccore/src/trace/arccore/trace/ITraceMng.h:156
Arccore::ITraceMng::info
virtual TraceMessage info()=0
Flot pour un message d'information.
Arccore::NotSupportedException
Exception lorsqu'une opération n'est pas supportée.
Definition arccore/src/base/arccore/base/NotSupportedException.h:33
Arccore::String
Chaîne de caractères unicode.
Definition arccore/src/base/arccore/base/String.h:70
Arccore::TraceAccessor::pwarning
TraceMessage pwarning() const
Definition TraceAccessor.cc:192
Arccore::TraceAccessor::traceMng
ITraceMng * traceMng() const
Gestionnaire de trace.
Definition TraceAccessor.cc:72
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::Int64Array
Array< Int64 > Int64Array
Tableau dynamique à une dimension d'entiers 64 bits.
Definition UtilsTypes.h:325
Arcane::arcaneCheckArraySize
Integer arcaneCheckArraySize(unsigned long long size)
Vérifie que size peut être converti dans un 'Integer' pour servir de taille à un tableau....
Definition ArcaneGlobal.cc:152
Arcane::Int64UniqueArray
UniqueArray< Int64 > Int64UniqueArray
Tableau dynamique à une dimension d'entiers 64 bits.
Definition UtilsTypes.h:513
Arcane::Real3UniqueArray
UniqueArray< Real3 > Real3UniqueArray
Tableau dynamique à une dimension de vecteurs de rang 3.
Definition UtilsTypes.h:529
Arcane::Int32UniqueArray
UniqueArray< Int32 > Int32UniqueArray
Tableau dynamique à une dimension d'entiers 32 bits.
Definition UtilsTypes.h:515
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::IK_Face
@ IK_Face
Entité de maillage de genre face.
Definition ArcaneTypes.h:156
Arcane::IK_Edge
@ IK_Edge
Entité de maillage de genre arête.
Definition ArcaneTypes.h:155
Arcane::DT_Real2x2
@ DT_Real2x2
Donnée de type tenseur 3x3.
Definition DataTypes.h:48
Arcane::DT_Real3x3
@ DT_Real3x3
Donnée de type tenseur 3x3.
Definition DataTypes.h:49
Arcane::DT_Int32
@ DT_Int32
Donnée de type entier 32 bits.
Definition DataTypes.h:43
Arcane::DT_Real3
@ DT_Real3
Donnée de type vecteur 3.
Definition DataTypes.h:47
Arcane::DT_Int64
@ DT_Int64
Donnée de type entier 64 bits.
Definition DataTypes.h:44
Arcane::DT_Real2
@ DT_Real2
Donnée de type vecteur 2.
Definition DataTypes.h:46
Arcane::DT_Real
@ DT_Real
Donnée de type réel.
Definition DataTypes.h:41
Arcane::DT_Byte
@ DT_Byte
Donnée de type octet.
Definition DataTypes.h:40
Arcane::Int64ConstArrayView
ConstArrayView< Int64 > Int64ConstArrayView
Equivalent C d'un tableau à une dimension d'entiers 64 bits.
Definition UtilsTypes.h:638
Arccore::Integer
Int32 Integer
Type représentant un entier.
Definition ArccoreGlobal.h:240