1 #ifndef MED_FIELD_DRIVER_HXX
2 #define MED_FIELD_DRIVER_HXX
6 #include "MEDMEM_define.hxx"
8 #include "MEDMEM_GenDriver.hxx"
11 #include "MEDMEM_STRING.hxx"
12 #include "MEDMEM_Exception.hxx"
13 #include "MEDMEM_Unit.hxx"
14 #include "MEDMEM_Array.hxx"
15 #include "MEDMEM_Support.hxx"
16 //#include "MEDMEM_Field.hxx"
17 #include "MEDMEM_Mesh.hxx"
19 //using namespace MED_FR ;
22 template <class T> class FIELD;
24 // A QD LA CLASSE MED_ALL_ELEMENTS_DRIVER.... :) pour mutualiser le open ..... avec led _medIdt...
30 Generic part : implement open and close methods.
34 template <class T> class MED_FIELD_DRIVER : public GENDRIVER
39 MED_FR::med_idt _medIdt;
47 // all MED cell type ?? Classe de Définition ??
48 // static const medGeometryElement all_cell_type[MED_NBR_GEOMETRIE_MAILLE];
50 // static const char * const all_cell_type_tab [MED_NBR_GEOMETRIE_MAILLE];
55 MED_FIELD_DRIVER():GENDRIVER(),
56 _ptrField((FIELD<T> *)MED_NULL),_medIdt(MED_INVALID),
57 _fieldName(""),_fieldNum(MED_INVALID) {}
61 MED_FIELD_DRIVER(const string & fileName, FIELD<T> * ptrField,
62 med_mode_acces accessMode)
63 : GENDRIVER(fileName,accessMode),
64 _ptrField((FIELD<T> *) ptrField),_medIdt(MED_INVALID),
65 _fieldName(fileName),_fieldNum(MED_INVALID)
72 MED_FIELD_DRIVER(const MED_FIELD_DRIVER & fieldDriver):
73 GENDRIVER(fieldDriver),
74 _ptrField(fieldDriver._ptrField),
76 _fieldName(fieldDriver._fieldName),
77 _fieldNum(fieldDriver._fieldNum)
84 virtual ~MED_FIELD_DRIVER() {
87 void open() throw (MEDEXCEPTION)
89 const char * LOC = "MED_FIELD_DRIVER::open() ";
92 // we must set fieldname before open, because we must find field number in file (if it exist !!!)
93 if ( _fileName == "" )
94 throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
95 << "_fileName is |\"\"|, please set a correct fileName before calling open()"
99 MESSAGE(LOC<<"_fileName.c_str : "<< _fileName.c_str()<<",mode : "<< _accessMode);
100 _medIdt = MED_FR::MEDouvrir( (const_cast <char *> (_fileName.c_str())),(MED_FR::med_mode_acces) _accessMode);
101 MESSAGE(LOC<<"_medIdt : "<< _medIdt );
105 _status = MED_INVALID;
106 _medIdt = MED_INVALID;
107 throw MED_EXCEPTION (LOCALIZED( STRING(LOC)
108 << "Can't open |" << _fileName
109 << "|, _medIdt : " << _medIdt
118 BEGIN_OF("MED_FIELD_DRIVER::close()");
119 MED_FR::med_int err = 0;
120 if (_status == MED_OPENED) {
121 err=MED_FR::MEDfermer(_medIdt);
122 H5close(); // If we call H5close() all the files are closed.
123 _status = MED_CLOSED;
124 _medIdt = MED_INVALID;
125 MESSAGE(" MED_FIELD_DRIVER::close() : MEDfermer : _medIdt= " << _medIdt );
126 MESSAGE(" MED_FIELD_DRIVER::close() : MEDfermer : err = " << err );
128 END_OF("MED_FIELD_DRIVER::close()");
131 virtual void write( void ) const = 0 ;
132 virtual void read ( void ) = 0 ;
135 Set the name of the FIELD asked in file.
137 It could be different than the name of the FIELD object.
139 void setFieldName(const string & fieldName) ;
141 Get the name of the FIELD asked in file.
143 string getFieldName() const ;
146 virtual GENDRIVER * copy ( void ) const = 0 ;
152 Driver Med for FIELD : Read only.
154 Implement read method.
158 template <class T> class MED_FIELD_RDONLY_DRIVER : public virtual MED_FIELD_DRIVER<T>
166 MED_FIELD_RDONLY_DRIVER():MED_FIELD_DRIVER<T>() {};
171 MED_FIELD_RDONLY_DRIVER(const string & fileName, FIELD<T> * ptrField):
172 MED_FIELD_DRIVER<T>(fileName,ptrField,MED_RDONLY) {
173 BEGIN_OF("MED_FIELD_RDONLY_DRIVER::MED_FIELD_RDONLY_DRIVER(const string & fileName, const FIELD<T> * ptrField)");
174 END_OF("MED_FIELD_RDONLY_DRIVER::MED_FIELD_RDONLY_DRIVER(const string & fileName, const FIELD<T> * ptrField)");
180 MED_FIELD_RDONLY_DRIVER(const MED_FIELD_RDONLY_DRIVER & fieldDriver):
181 MED_FIELD_DRIVER<T>(fieldDriver) {};
186 virtual ~MED_FIELD_RDONLY_DRIVER() {};
188 // CREER UNE METHODE POUR LIRE LA LISTE DES MAILLAGES .....
191 Return a MEDEXCEPTION : it is the read-only driver.
193 void write( void ) const throw (MEDEXCEPTION) ;
195 Read FIELD in the specified file.
197 void read ( void ) throw (MEDEXCEPTION) ;
200 GENDRIVER * copy( void ) const ;
206 Driver Med for FIELD : Write only.
208 Implement write method.
212 template <class T> class MED_FIELD_WRONLY_DRIVER : public virtual MED_FIELD_DRIVER<T> {
219 MED_FIELD_WRONLY_DRIVER():MED_FIELD_DRIVER<T>() {}
224 MED_FIELD_WRONLY_DRIVER(const string & fileName, FIELD<T> * ptrField):
225 MED_FIELD_DRIVER<T>(fileName,ptrField,MED_WRONLY)
227 BEGIN_OF("MED_FIELD_WRONLY_DRIVER::MED_FIELD_WRONLY_DRIVER(const string & fileName, const FIELD<T> * ptrField)");
228 END_OF("MED_FIELD_WRONLY_DRIVER::MED_FIELD_WRONLY_DRIVER(const string & fileName, const FIELD<T> * ptrField)");
234 MED_FIELD_WRONLY_DRIVER(const MED_FIELD_WRONLY_DRIVER & fieldDriver):
235 MED_FIELD_DRIVER<T>(fieldDriver) {};
240 virtual ~MED_FIELD_WRONLY_DRIVER() {};
243 Write FIELD in the specified file.
245 void write( void ) const throw (MEDEXCEPTION) ;
247 Return a MEDEXCEPTION : it is the write-only driver.
249 void read ( void ) throw (MEDEXCEPTION) ;
252 GENDRIVER * copy( void ) const ;
259 Driver Med for FIELD : Read write.
260 - Use read method from MED_FIELD_RDONLY_DRIVER
261 - Use write method from MED_FIELD_WDONLY_DRIVER
265 template <class T> class MED_FIELD_RDWR_DRIVER : public MED_FIELD_RDONLY_DRIVER<T>, public MED_FIELD_WRONLY_DRIVER<T> {
272 MED_FIELD_RDWR_DRIVER():MED_FIELD_DRIVER<T>() {}
277 MED_FIELD_RDWR_DRIVER(const string & fileName, FIELD<T> * ptrField):
278 MED_FIELD_DRIVER<T>(fileName,ptrField,MED_RDWR)
280 BEGIN_OF("MED_FIELD_RDWR_DRIVER::MED_FIELD_RDWR_DRIVER(const string & fileName, const FIELD<T> * ptrField)");
281 //_accessMode = MED_RDWR ;
282 END_OF("MED_FIELD_RDWR_DRIVER::MED_FIELD_RDWR_DRIVER(const string & fileName, const FIELD<T> * ptrField)");
288 MED_FIELD_RDWR_DRIVER(const MED_FIELD_RDWR_DRIVER & fieldDriver):
289 MED_FIELD_DRIVER<T>(fieldDriver) {};
294 ~MED_FIELD_RDWR_DRIVER() {};
297 Write FIELD in the specified file.
299 void write(void) const throw (MEDEXCEPTION) ;
301 Read FIELD in the specified file.
303 void read (void) throw (MEDEXCEPTION) ;
306 GENDRIVER * copy( void ) const ;
312 /*-------------------------*/
313 /* template implementation */
314 /*-------------------------*/
316 using namespace MEDMEM;
317 /*--------------------- DRIVER PART -------------------------------*/
319 template <class T> void MED_FIELD_DRIVER<T>::setFieldName(const string & fieldName)
321 _fieldName = fieldName;
324 template <class T> string MED_FIELD_DRIVER<T>::getFieldName() const
329 // template <class T> void MED_FIELD_DRIVER<T>::search_field() {
330 // const char * LOC = "template <class T> class MED_FIELD_DRIVER::search_field() :";
332 // // we search the field number !!!!
333 // if (_status==MED_OPENED)
334 // if (_fieldNum==MED_INVALID) {
336 // int numberOfFields = 0; //MED_INVALID
337 // // char fieldName[MED_TAILLE_NOM+1] = "";
338 // char fieldName[MED_TAILLE_NOM+1] ;
339 // int numberOfComponents = 0;
340 // char * componentName = (char *) MED_NULL;
341 // char * unitName = (char *) MED_NULL;
342 // MED_FR::med_type_champ type ;
343 // numberOfFields = MED_FR::MEDnChamp(_medIdt,0) ;
344 // if ( numberOfFields <= 0 )
345 // throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<": No Field found !"));
346 // for (int i=1;i<=numberOfFields;i++) {
348 // numberOfComponents = MED_FR::MEDnChamp(_medIdt,i) ;
349 // if ( numberOfComponents <= 0 )
350 // throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
351 // << "Be careful there is no compound for field n°"
352 // << i << "in file |"<<_fileName<<"| !"));
354 // componentName = new char[numberOfComponents*MED_TAILLE_PNOM+1] ;
355 // unitName = new char[numberOfComponents*MED_TAILLE_PNOM+1] ;
357 // err = MED_FR::MEDchampInfo(_medIdt, i, fieldName, &type, componentName,
358 // unitName, numberOfComponents) ;
360 // delete[] componentName ;
361 // delete[] unitName ;
362 // MESSAGE("Champ "<<i<<" : #" << fieldName <<"# et recherche #"<<_fieldName.c_str()<<"#");
363 // if ( !strcmp(fieldName,_fieldName.c_str()) ) {
364 // MESSAGE("FOUND FIELD "<< fieldName <<" : "<<i);
372 /*--------------------- RDONLY PART -------------------------------*/
374 template <class T> GENDRIVER * MED_FIELD_RDONLY_DRIVER<T>::copy(void) const
376 MED_FIELD_RDONLY_DRIVER<T> * myDriver =
377 new MED_FIELD_RDONLY_DRIVER<T>(*this);
381 template <class T> void MED_FIELD_RDONLY_DRIVER<T>::read(void)
384 const char * LOC = " MED_FIELD_RDONLY_DRIVER::read() " ;
387 if (_ptrField->_name=="")
388 _ptrField->_name = _fieldName ;
390 _fieldName = _ptrField->_name; // bug indetermine ! apres avoir fait readfilestruct, lorsque je recupere le champ, tout est bon sauf le nom du champ dans le driver !!!!!
392 MESSAGE("###### "<<LOC<<" fieldNameDRIVER : "<<_fieldName<<" fieldName : "<<_ptrField->_name);
394 string MeshName = _ptrField->getSupport()->getMesh()->getName() ;
396 if (_status==MED_OPENED)
402 fieldName = new char[MED_TAILLE_NOM+1] ;
404 int numberOfComponents = 0;
405 char * componentName = (char *) MED_NULL;
406 char * unitName = (char *) MED_NULL;
407 MED_FR::med_type_champ type ;
409 // we search the field number !!!!
410 if (_fieldNum==MED_INVALID) {
411 int numberOfFields = 0; //MED_INVALID
412 numberOfFields = MED_FR::MEDnChamp(_medIdt,0) ;
413 if ( numberOfFields <= 0 )
414 throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<": No Field found !"));
415 for (int i=1;i<=numberOfFields;i++) {
417 numberOfComponents = MED_FR::MEDnChamp(_medIdt,i) ;
418 if ( numberOfComponents <= 0 )
419 // throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
420 // << "Be careful there is no compound for field n°"
421 // << i << "in file |"<<_fileName<<"| !"));
422 MESSAGE(LOC<<"Be careful there is no compound for field n°"<<i<<"in file |"<<_fileName<<"| !");
424 componentName = new char[numberOfComponents*MED_TAILLE_PNOM+1] ;
425 unitName = new char[numberOfComponents*MED_TAILLE_PNOM+1] ;
427 err = MED_FR::MEDchampInfo(_medIdt, i, fieldName, &type, componentName,
428 unitName, numberOfComponents) ;
430 MESSAGE("Champ "<<i<<" : #" << fieldName <<"# et recherche #"<<_fieldName.c_str()<<"#");
431 if ( !strcmp(fieldName,_fieldName.c_str()) ) {
432 MESSAGE("FOUND FIELD "<< fieldName <<" : "<<i);
436 // not found : release memory and search next field !
437 delete[] componentName ;
444 if (_fieldNum==MED_INVALID)
445 throw MEDEXCEPTION(LOCALIZED( STRING(LOC) << ": Field "<<_fieldName << " not found in file " << _fileName ) );
446 MESSAGE ("FieldNum : "<<_fieldNum);
449 // int NumberOfComponents = MED_FR::MEDnChamp(_medIdt,_fieldNum) ;
450 if (numberOfComponents < 1)
451 throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"no component")) ; // use iostring !
452 // test type to check if it is rigth !!!???
453 _ptrField->_numberOfComponents = numberOfComponents ;
454 _ptrField->_componentsTypes = new int[numberOfComponents] ;
455 _ptrField->_componentsNames = new string[numberOfComponents] ;
456 _ptrField->_componentsUnits = new UNIT[numberOfComponents] ;
457 _ptrField->_componentsDescriptions = new string[numberOfComponents] ;
458 _ptrField->_MEDComponentsUnits = new string[numberOfComponents] ;
459 for (int i=0; i<numberOfComponents; i++) {
460 _ptrField->_componentsTypes[i] = 1 ;
462 // PG : what about space !!!
463 _ptrField->_componentsNames[i] = string(componentName,i*MED_TAILLE_PNOM,MED_TAILLE_PNOM) ;
464 SCRUTE(_ptrField->_componentsNames[i]);
465 _ptrField->_MEDComponentsUnits[i] = string(unitName,i*MED_TAILLE_PNOM,MED_TAILLE_PNOM) ;
466 SCRUTE(_ptrField->_MEDComponentsUnits[i]);
468 delete[] componentName;
471 // read values for each geometric type in _support
472 int NumberOfTypes = _ptrField->_support->getNumberOfTypes() ;
473 const medGeometryElement *Types = _ptrField->_support->getTypes() ;
474 T ** myValues = new (T*)[NumberOfTypes] ;
475 int * NumberOfValues = new int[NumberOfTypes] ;
476 int TotalNumberOfValues = 0 ;
477 MESSAGE ("NumberOfTypes :"<< NumberOfTypes);
478 for (int i=0; i<NumberOfTypes; i++) {
479 MESSAGE ("Type["<<i+1<<"] :"<< Types[i]);
480 MESSAGE ("Entity :"<<_ptrField->_support->getEntity());
481 // NumberOfValues[i] =
483 // const_cast <char*> (_fieldName.c_str()),
484 // (MED_FR::med_entite_maillage)_ptrField->_support->getEntity(),
485 // (MED_FR::med_geometrie_element)Types[i],
486 // _ptrField->_iterationNumber,
487 // _ptrField->_orderNumber) ; // no time step ! prend en compte le nbre de pt de gauss
488 // test if NumberOfValues is the same in _support !!! TODO that !!
490 // we could allocate array
491 // Be really carefull about the profil; especially the last arg of
496 const_cast <char*> (_fieldName.c_str()),
497 (MED_FR::med_entite_maillage)_ptrField->_support->getEntity(),
498 (MED_FR::med_geometrie_element) Types[i],
499 _ptrField->_iterationNumber, _ptrField->_orderNumber,
500 const_cast <char*> (_ptrField->_support->getMesh()->getName().c_str()),
501 MED_FR::MED_COMPACT) ;
503 myValues[i] = new T[ NumberOfValues[i]*numberOfComponents ] ;
504 TotalNumberOfValues+=NumberOfValues[i] ;// diviser par le nombre de point de gauss
505 char * ProfilName = new char[MED_TAILLE_NOM+1];
506 char * LocalGaussName = new char[MED_TAILLE_NOM+1];
507 MESSAGE ("NumberOfValues :"<< NumberOfValues[i]);
508 MESSAGE ("NumberOfComponents :"<< numberOfComponents);
509 MESSAGE ("MESH_NAME :"<< MeshName.c_str());
510 MESSAGE ("FIELD_NAME :"<< _fieldName.c_str());
511 MESSAGE ("MED_ENTITE :"<< (MED_FR::med_entite_maillage) _ptrField->_support->getEntity());
512 MESSAGE("MED_GEOM :"<<(MED_FR::med_geometrie_element)Types[i]);
513 MESSAGE("Iteration :"<<_ptrField->getIterationNumber());
514 MESSAGE("Order :"<<_ptrField->getOrderNumber());
515 _ptrField->_numberOfValues+=NumberOfValues[i]; // problem with gauss point : _numberOfValues != TotalNumberOfValues !!!!!!!
517 err = MEDchampLire(_medIdt,const_cast <char*> (MeshName.c_str()),
518 const_cast <char*> (_fieldName.c_str()),
519 (unsigned char*) myValues[i],
520 MED_FR::MED_NO_INTERLACE,MED_ALL,
521 LocalGaussName,ProfilName,
522 MED_FR::MED_NO_PFLMOD,
523 (MED_FR::med_entite_maillage) _ptrField->_support->getEntity(),(MED_FR::med_geometrie_element)Types[i],
524 _ptrField->getIterationNumber(),
525 _ptrField->getOrderNumber());
528 // we must do some delete !!!
529 for(int j=0; j<=i;j++)
530 delete[] myValues[j];
532 delete[] NumberOfValues ;
534 delete[] LocalGaussName;
535 delete[] _ptrField->_componentsTypes ;
536 delete[] _ptrField->_componentsNames ;
537 delete[] _ptrField->_componentsUnits ;
538 delete[] _ptrField->_componentsDescriptions ;
539 delete[] _ptrField->_MEDComponentsUnits ;
540 _ptrField->_componentsTypes = NULL ;
541 _ptrField->_componentsNames = NULL ;
542 _ptrField->_componentsUnits = NULL ;
543 _ptrField->_componentsDescriptions = NULL ;
544 _ptrField->_MEDComponentsUnits = NULL ;
545 _fieldNum = MED_INVALID ; // we have not found right field, so reset the field number
546 throw MEDEXCEPTION( LOCALIZED( STRING(LOC) <<": ERROR when read value")) ;
549 // At this time ProfilName should be MED_FR::MED_NOPFL and
550 // LocalGaussName should be MED_FR::MED_NOGAUSS
551 delete[] ProfilName ;
552 delete[] LocalGaussName ;
555 // probleme avec les points de gauss : voir lorsqu-il y en a (!= 1)
556 // MEDARRAY<T> * Values = new MEDARRAY<T>(_ptrField->getNumberOfComponents(),TotalNumberOfValues/_ptrField->getNumberOfComponents(),MED_EN::MED_NO_INTERLACE);
558 if (_ptrField->_value==NULL)
559 _ptrField->_value=new MEDARRAY<T>(numberOfComponents,TotalNumberOfValues,MED_EN::MED_NO_INTERLACE);
561 MEDARRAY<T> * Values = _ptrField->_value ; // create by constructor ???
562 // check if dimensions are right : inutile : c'est dans le constructeur !!!
563 //if (Values->getLeadingValue() != numberOfComponents)
564 // throw MEDEXCEPTION( LOCALIZED( STRING(LOC) <<": leading dimension are false : "<<Values->getLeadingValue()<<" and "<<numberOfComponents) ) ;
565 //if (Values->getLengthValue() != TotalNumberOfValues)
566 // throw MEDEXCEPTION( LOCALIZED( STRING(LOC) <<": length dimension are false : "<<Values->getLengthValue()<<" and "<<TotalNumberOfValues) ) ;
568 for (int i=0; i<numberOfComponents; i++) {
569 //T * ValuesT = Values->getRow(i+1) ;
571 for (int j=0; j<NumberOfTypes; j++) {
572 T * myValue = myValues[j] ;
573 int NumberOf = NumberOfValues[j] ;
574 // _ptrField->_numberOfValues+=NumberOf; // problem with gauss point : _numberOfValues != TotalNumberOfValues !!!!!!!
575 int offset = NumberOf*i ;
576 for (int k=0 ; k<NumberOf; k++) {
577 //ValuesT[Count]=myValue[k+offset] ;
578 Values->setIJ(Count,i+1,myValue[k+offset]);
580 SCRUTE(Values->getIJ(Count,i+1));
586 for (int j=0; j<NumberOfTypes; j++)
587 delete[] myValues[j] ;
589 delete[] NumberOfValues ;
591 _ptrField->_isRead = true ;
597 template <class T> void MED_FIELD_RDONLY_DRIVER<T>::write( void ) const
600 throw MEDEXCEPTION("MED_FIELD_RDONLY_DRIVER::write : Can't write with a RDONLY driver !");
603 /*--------------------- WRONLY PART -------------------------------*/
605 template <class T> GENDRIVER * MED_FIELD_WRONLY_DRIVER<T>::copy(void) const
607 MED_FIELD_WRONLY_DRIVER<T> * myDriver =
608 new MED_FIELD_WRONLY_DRIVER<T>(*this);
612 template <class T> void MED_FIELD_WRONLY_DRIVER<T>::read (void)
615 throw MEDEXCEPTION("MED_FIELD_WRONLY_DRIVER::read : Can't read with a WRONLY driver !");
618 template <class T> void MED_FIELD_WRONLY_DRIVER<T>::write(void) const
621 const char * LOC = "MED_FIELD_WRONLY_DRIVER::write(void) const " ;
623 if (_status==MED_OPENED)
627 int component_count=_ptrField->getNumberOfComponents();
628 string component_name(component_count*MED_TAILLE_PNOM,' ') ;
629 string component_unit(component_count*MED_TAILLE_PNOM,' ') ;
631 const string * listcomponent_name=_ptrField->getComponentsNames() ;
632 const string * listcomponent_unit=_ptrField->getMEDComponentsUnits() ;
634 for (int i=0; i < component_count ; i++) {
635 length = min(MED_TAILLE_PNOM,(int)listcomponent_name[i].size());
636 component_name.replace(i*MED_TAILLE_PNOM,length,
637 listcomponent_name[i],0,length);
638 length = min(MED_TAILLE_PNOM,(int)listcomponent_unit[i].size());
639 component_unit.replace(i*MED_TAILLE_PNOM,length,
640 listcomponent_unit[i],0,length);
643 MESSAGE("component_name=|"<<component_name<<"|");
644 MESSAGE("component_unit=|"<<component_unit<<"|");
646 MED_EN::med_type_champ ValueType=_ptrField->getValueType() ;
648 MESSAGE("Template Type =|"<<ValueType<<"|");
650 // le champ existe deja ???
651 char * champName = new char[MED_TAILLE_NOM+1] ;
652 MED_FR::med_type_champ type ;
656 int n = MED_FR::MEDnChamp(_medIdt,0);
658 for (int i=1; i<=n; i++) {
659 nbComp = MED_FR::MEDnChamp(_medIdt,i);
660 compName = new char[MED_TAILLE_PNOM*nbComp+1];
661 compUnit = new char[MED_TAILLE_PNOM*nbComp+1];
662 err = MED_FR::MEDchampInfo(_medIdt,i,champName,&type,compName,compUnit,nbComp);
664 if (strcmp(champName,_ptrField->getName().c_str())==0) { // Found !
674 if (nbComp != component_count)
675 throw MEDEXCEPTION( LOCALIZED (STRING(LOC)
676 <<": Field exist in file, but number of component are different : "<<nbComp<<" in file and "<<component_count<<" in memory."
679 // component name and unit
680 MESSAGE(LOC<<" Component name in file : "<<compName);
681 MESSAGE(LOC<<" Component name in memory : "<<component_name);
682 MESSAGE(LOC<<" Component unit in file : "<<compUnit);
683 MESSAGE(LOC<<" Component unit in memory : "<<component_unit);
688 // Verify the field doesn't exist
690 string dataGroupName = "/CHA/";
691 dataGroupName += _ptrField->getName();
692 MESSAGE(LOC << "|" << dataGroupName << "|" );
693 med_idt gid = H5Gopen(_medIdt, dataGroupName.c_str() );
697 err=MED_FR::MEDchampCr(_medIdt,
698 const_cast <char*> ((_ptrField->getName()).c_str()),
699 (MED_FR::med_type_champ) ValueType,
700 const_cast <char*> ( component_name.c_str() ),
701 const_cast <char*> ( component_unit.c_str() ),
704 throw MEDEXCEPTION( LOCALIZED (STRING(LOC)
705 << ": Error MEDchampCr : "<<err
712 const SUPPORT * mySupport = _ptrField->getSupport() ;
714 if (! mySupport->isOnAllElements())
715 throw MEDEXCEPTION( LOCALIZED (STRING(LOC)
716 <<": Field must be on all entity"
720 MESH * myMesh = mySupport->getMesh() ;
721 string MeshName = myMesh->getName() ;
722 //MED_EN::medModeSwitch Mode = _ptrField->_value->getMode() ;
723 // on boucle sur tout les types pour ecrire les tableaux de valeur
724 int NumberOfType = mySupport->getNumberOfTypes() ;
726 const medGeometryElement * Types = mySupport->getTypes() ;
727 const int * NumberOfGaussPoint = mySupport->getNumberOfGaussPoint() ;
728 for (int i=0;i<NumberOfType;i++) {
729 int NumberOfElements = mySupport->getNumberOfElements(Types[i]) ;
731 const T * value = _ptrField->getValueI(MED_EN::MED_FULL_INTERLACE,Index) ;
733 MESSAGE("_medIdt : "<<_medIdt);
734 MESSAGE("MeshName.c_str() : "<<MeshName.c_str());
735 MESSAGE("_ptrField->getName() : "<<_ptrField->getName());
736 MESSAGE("value : "<<value);
737 MESSAGE("NumberOfElements : "<<NumberOfElements);
738 MESSAGE("NumberOfGaussPoint[i] : "<<NumberOfGaussPoint[i]);
739 MESSAGE("mySupport->getEntity() : "<<mySupport->getEntity());
740 MESSAGE("Types[i] : "<<Types[i]);
741 MESSAGE("_ptrField->getIterationNumber() : "<<_ptrField->getIterationNumber());
742 MESSAGE("_ptrField->getTime() : "<<_ptrField->getTime());
743 MESSAGE("_ptrField->getOrderNumber() : "<<_ptrField->getOrderNumber());
745 /* char chanom[MED_TAILLE_NOM+1];
746 char chacomp[MED_TAILLE_NOM+1];
747 char chaunit[MED_TAILLE_NOM+1];
748 MED_FR::med_type_champ chatype;
751 err=MED_FR::MEDchampInfo(_medIdt,1,chanom,&chatype,chacomp,chaunit,chancomp);
755 cout<<"=======================================================================> gros probleme"<<endl;
758 cout<<"==================> nom lu = "<<chanom<<endl;
759 cout<<"==================> type lu = "<<chatype<<endl;
760 cout<<"==================> nom composante lu = "<<chacomp<<endl;
761 cout<<"==================> nom unit lu = "<<chaunit<<endl;
762 cout<<"==================> valeur de MED_FR::MED_REEL64 = "<<MED_FR::MED_REEL64<<endl;
765 // err=MED_FR::MEDchampEcr(_medIdt,
766 // const_cast <char*> ( MeshName.c_str()) , //( string(mesh_name).resize(MED_TAILLE_NOM).c_str())
767 // const_cast <char*> ( (_ptrField->getName()).c_str()),
768 // (unsigned char*)value,
769 // MED_FR::MED_FULL_INTERLACE,
771 // NumberOfGaussPoint[i],
774 // MED_FR::MED_REMP, // PROFIL NON GERE, mode de remplacement non géré
775 // (MED_FR::med_entite_maillage)mySupport->getEntity(),
776 // (MED_FR::med_geometrie_element)Types[i],
777 // _ptrField->getIterationNumber(),
779 // _ptrField->getTime(),
780 // _ptrField->getOrderNumber()
783 err=MED_FR::MEDchampEcr(_medIdt,
784 const_cast <char*> ( MeshName.c_str()) , //( string(mesh_name).resize(MED_TAILLE_NOM).c_str())
785 const_cast <char*> ( (_ptrField->getName()).c_str()),
786 (unsigned char*)value,
787 MED_FR::MED_FULL_INTERLACE,
788 NumberOfElements*NumberOfGaussPoint[i],
789 MED_NOGAUSS, MED_ALL, MED_NOPFL,
790 MED_FR::MED_NO_PFLMOD, // PROFIL NON GERE, mode de remplacement non géré
791 (MED_FR::med_entite_maillage)mySupport->getEntity(),
792 (MED_FR::med_geometrie_element)Types[i],
793 _ptrField->getIterationNumber(),
795 _ptrField->getTime(),
796 _ptrField->getOrderNumber()
799 if (err < MED_VALID )
800 throw MEDEXCEPTION(LOCALIZED( STRING(LOC)
801 <<": Error in writing Field "<< _ptrField->getName() <<", type "<<Types[i]
805 Index += NumberOfElements ;
813 /*--------------------- RDWR PART -------------------------------*/
815 template <class T> GENDRIVER * MED_FIELD_RDWR_DRIVER<T>::copy(void) const
817 MED_FIELD_RDWR_DRIVER<T> * myDriver =
818 new MED_FIELD_RDWR_DRIVER<T>(*this);
822 template <class T> void MED_FIELD_RDWR_DRIVER<T>::write(void) const
825 BEGIN_OF("MED_FIELD_RDWR_DRIVER::write(void)");
826 MED_FIELD_WRONLY_DRIVER<T>::write();
827 END_OF("MED_FIELD_RDWR_DRIVER::write(void)");
830 template <class T> void MED_FIELD_RDWR_DRIVER<T>::read (void)
833 BEGIN_OF("MED_FIELD_RDWR_DRIVER::read(void)");
834 MED_FIELD_RDONLY_DRIVER<T>::read();
835 END_OF("MED_FIELD_RDWR_DRIVER::read(void)");
837 /*-----------------------------------------------------------------*/
839 #endif /* MED_FIELD_DRIVER_HXX */