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 ;
21 template <class T> class FIELD;
23 // A QD LA CLASSE MED_ALL_ELEMENTS_DRIVER.... :) pour mutualiser le open ..... avec led _medIdt...
29 Generic part : implement open and close methods.
33 template <class T> class MED_FIELD_DRIVER : public GENDRIVER
38 MED_FR::med_idt _medIdt;
46 // all MED cell type ?? Classe de Définition ??
47 // static const medGeometryElement all_cell_type[MED_NBR_GEOMETRIE_MAILLE];
49 // static const char * const all_cell_type_tab [MED_NBR_GEOMETRIE_MAILLE];
54 MED_FIELD_DRIVER():GENDRIVER(),
55 _ptrField((FIELD<T> *)MED_NULL),_medIdt(MED_INVALID),
56 _fieldName(""),_fieldNum(MED_INVALID) {}
60 MED_FIELD_DRIVER(const string & fileName, FIELD<T> * ptrField,
61 med_mode_acces accessMode)
62 : GENDRIVER(fileName,accessMode),
63 _ptrField((FIELD<T> *) ptrField),_medIdt(MED_INVALID),
64 _fieldName(fileName),_fieldNum(MED_INVALID)
71 MED_FIELD_DRIVER(const MED_FIELD_DRIVER & fieldDriver):
72 GENDRIVER(fieldDriver),
73 _ptrField(fieldDriver._ptrField),
75 _fieldName(fieldDriver._fieldName),
76 _fieldNum(fieldDriver._fieldNum)
83 virtual ~MED_FIELD_DRIVER() {
86 void open() throw (MEDEXCEPTION)
88 const char * LOC = "MED_FIELD_DRIVER::open() ";
91 // we must set fieldname before open, because we must find field number in file (if it exist !!!)
92 if ( _fileName == "" )
93 throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
94 << "_fileName is |\"\"|, please set a correct fileName before calling open()"
98 MESSAGE(LOC<<"_fileName.c_str : "<< _fileName.c_str()<<",mode : "<< _accessMode);
99 _medIdt = MED_FR::MEDouvrir( (const_cast <char *> (_fileName.c_str())),(MED_FR::med_mode_acces) _accessMode);
100 MESSAGE(LOC<<"_medIdt : "<< _medIdt );
104 _status = MED_INVALID;
105 _medIdt = MED_INVALID;
106 throw MED_EXCEPTION (LOCALIZED( STRING(LOC)
107 << "Can't open |" << _fileName
108 << "|, _medIdt : " << _medIdt
117 BEGIN_OF("MED_FIELD_DRIVER::close()");
118 MED_FR::med_int err = 0;
119 if (_status == MED_OPENED) {
120 err=MED_FR::MEDfermer(_medIdt);
121 H5close(); // If we call H5close() all the files are closed.
122 _status = MED_CLOSED;
123 _medIdt = MED_INVALID;
124 MESSAGE(" MED_FIELD_DRIVER::close() : MEDfermer : _medIdt= " << _medIdt );
125 MESSAGE(" MED_FIELD_DRIVER::close() : MEDfermer : err = " << err );
127 END_OF("MED_FIELD_DRIVER::close()");
130 virtual void write( void ) const = 0 ;
131 virtual void read ( void ) = 0 ;
134 Set the name of the FIELD asked in file.
136 It could be different than the name of the FIELD object.
138 void setFieldName(const string & fieldName) ;
140 Get the name of the FIELD asked in file.
142 string getFieldName() const ;
145 virtual GENDRIVER * copy ( void ) const = 0 ;
151 Driver Med for FIELD : Read only.
153 Implement read method.
157 template <class T> class MED_FIELD_RDONLY_DRIVER : public virtual MED_FIELD_DRIVER<T>
165 MED_FIELD_RDONLY_DRIVER():MED_FIELD_DRIVER<T>() {};
170 MED_FIELD_RDONLY_DRIVER(const string & fileName, FIELD<T> * ptrField):
171 MED_FIELD_DRIVER<T>(fileName,ptrField,MED_RDONLY) {
172 BEGIN_OF("MED_FIELD_RDONLY_DRIVER::MED_FIELD_RDONLY_DRIVER(const string & fileName, const FIELD<T> * ptrField)");
173 END_OF("MED_FIELD_RDONLY_DRIVER::MED_FIELD_RDONLY_DRIVER(const string & fileName, const FIELD<T> * ptrField)");
179 MED_FIELD_RDONLY_DRIVER(const MED_FIELD_RDONLY_DRIVER & fieldDriver):
180 MED_FIELD_DRIVER<T>(fieldDriver) {};
185 virtual ~MED_FIELD_RDONLY_DRIVER() {};
187 // CREER UNE METHODE POUR LIRE LA LISTE DES MAILLAGES .....
190 Return a MEDEXCEPTION : it is the read-only driver.
192 void write( void ) const throw (MEDEXCEPTION) ;
194 Read FIELD in the specified file.
196 void read ( void ) throw (MEDEXCEPTION) ;
199 GENDRIVER * copy( void ) const ;
205 Driver Med for FIELD : Write only.
207 Implement write method.
211 template <class T> class MED_FIELD_WRONLY_DRIVER : public virtual MED_FIELD_DRIVER<T> {
218 MED_FIELD_WRONLY_DRIVER():MED_FIELD_DRIVER<T>() {}
223 MED_FIELD_WRONLY_DRIVER(const string & fileName, FIELD<T> * ptrField):
224 MED_FIELD_DRIVER<T>(fileName,ptrField,MED_WRONLY)
226 BEGIN_OF("MED_FIELD_WRONLY_DRIVER::MED_FIELD_WRONLY_DRIVER(const string & fileName, const FIELD<T> * ptrField)");
227 END_OF("MED_FIELD_WRONLY_DRIVER::MED_FIELD_WRONLY_DRIVER(const string & fileName, const FIELD<T> * ptrField)");
233 MED_FIELD_WRONLY_DRIVER(const MED_FIELD_WRONLY_DRIVER & fieldDriver):
234 MED_FIELD_DRIVER<T>(fieldDriver) {};
239 virtual ~MED_FIELD_WRONLY_DRIVER() {};
242 Write FIELD in the specified file.
244 void write( void ) const throw (MEDEXCEPTION) ;
246 Return a MEDEXCEPTION : it is the write-only driver.
248 void read ( void ) throw (MEDEXCEPTION) ;
251 GENDRIVER * copy( void ) const ;
258 Driver Med for FIELD : Read write.
259 - Use read method from MED_FIELD_RDONLY_DRIVER
260 - Use write method from MED_FIELD_WDONLY_DRIVER
264 template <class T> class MED_FIELD_RDWR_DRIVER : public MED_FIELD_RDONLY_DRIVER<T>, public MED_FIELD_WRONLY_DRIVER<T> {
271 MED_FIELD_RDWR_DRIVER():MED_FIELD_DRIVER<T>() {}
276 MED_FIELD_RDWR_DRIVER(const string & fileName, FIELD<T> * ptrField):
277 MED_FIELD_DRIVER<T>(fileName,ptrField,MED_RDWR)
279 BEGIN_OF("MED_FIELD_RDWR_DRIVER::MED_FIELD_RDWR_DRIVER(const string & fileName, const FIELD<T> * ptrField)");
280 //_accessMode = MED_RDWR ;
281 END_OF("MED_FIELD_RDWR_DRIVER::MED_FIELD_RDWR_DRIVER(const string & fileName, const FIELD<T> * ptrField)");
287 MED_FIELD_RDWR_DRIVER(const MED_FIELD_RDWR_DRIVER & fieldDriver):
288 MED_FIELD_DRIVER<T>(fieldDriver) {};
293 ~MED_FIELD_RDWR_DRIVER() {};
296 Write FIELD in the specified file.
298 void write(void) const throw (MEDEXCEPTION) ;
300 Read FIELD in the specified file.
302 void read (void) throw (MEDEXCEPTION) ;
305 GENDRIVER * copy( void ) const ;
310 /*-------------------------*/
311 /* template implementation */
312 /*-------------------------*/
314 /*--------------------- DRIVER PART -------------------------------*/
316 template <class T> void MED_FIELD_DRIVER<T>::setFieldName(const string & fieldName)
318 _fieldName = fieldName;
321 template <class T> string MED_FIELD_DRIVER<T>::getFieldName() const
326 // template <class T> void MED_FIELD_DRIVER<T>::search_field() {
327 // const char * LOC = "template <class T> class MED_FIELD_DRIVER::search_field() :";
329 // // we search the field number !!!!
330 // if (_status==MED_OPENED)
331 // if (_fieldNum==MED_INVALID) {
333 // int numberOfFields = 0; //MED_INVALID
334 // // char fieldName[MED_TAILLE_NOM+1] = "";
335 // char fieldName[MED_TAILLE_NOM+1] ;
336 // int numberOfComponents = 0;
337 // char * componentName = (char *) MED_NULL;
338 // char * unitName = (char *) MED_NULL;
339 // MED_FR::med_type_champ type ;
340 // numberOfFields = MED_FR::MEDnChamp(_medIdt,0) ;
341 // if ( numberOfFields <= 0 )
342 // throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<": No Field found !"));
343 // for (int i=1;i<=numberOfFields;i++) {
345 // numberOfComponents = MED_FR::MEDnChamp(_medIdt,i) ;
346 // if ( numberOfComponents <= 0 )
347 // throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
348 // << "Be careful there is no compound for field n°"
349 // << i << "in file |"<<_fileName<<"| !"));
351 // componentName = new char[numberOfComponents*MED_TAILLE_PNOM+1] ;
352 // unitName = new char[numberOfComponents*MED_TAILLE_PNOM+1] ;
354 // err = MED_FR::MEDchampInfo(_medIdt, i, fieldName, &type, componentName,
355 // unitName, numberOfComponents) ;
357 // delete[] componentName ;
358 // delete[] unitName ;
359 // MESSAGE("Champ "<<i<<" : #" << fieldName <<"# et recherche #"<<_fieldName.c_str()<<"#");
360 // if ( !strcmp(fieldName,_fieldName.c_str()) ) {
361 // MESSAGE("FOUND FIELD "<< fieldName <<" : "<<i);
369 /*--------------------- RDONLY PART -------------------------------*/
371 template <class T> GENDRIVER * MED_FIELD_RDONLY_DRIVER<T>::copy(void) const
373 MED_FIELD_RDONLY_DRIVER<T> * myDriver =
374 new MED_FIELD_RDONLY_DRIVER<T>(*this);
378 template <class T> void MED_FIELD_RDONLY_DRIVER<T>::read(void)
381 const char * LOC = " MED_FIELD_RDONLY_DRIVER::read() " ;
384 if (_ptrField->_name=="")
385 _ptrField->_name = _fieldName ;
387 _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 !!!!!
389 MESSAGE("###### "<<LOC<<" fieldNameDRIVER : "<<_fieldName<<" fieldName : "<<_ptrField->_name);
391 string MeshName = _ptrField->getSupport()->getMesh()->getName() ;
393 if (_status==MED_OPENED)
399 fieldName = new char[MED_TAILLE_NOM+1] ;
401 int numberOfComponents = 0;
402 char * componentName = (char *) MED_NULL;
403 char * unitName = (char *) MED_NULL;
404 MED_FR::med_type_champ type ;
406 // we search the field number !!!!
407 if (_fieldNum==MED_INVALID) {
408 int numberOfFields = 0; //MED_INVALID
409 numberOfFields = MED_FR::MEDnChamp(_medIdt,0) ;
410 if ( numberOfFields <= 0 )
411 throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<": No Field found !"));
412 for (int i=1;i<=numberOfFields;i++) {
414 numberOfComponents = MED_FR::MEDnChamp(_medIdt,i) ;
415 if ( numberOfComponents <= 0 )
416 // throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
417 // << "Be careful there is no compound for field n°"
418 // << i << "in file |"<<_fileName<<"| !"));
419 MESSAGE(LOC<<"Be careful there is no compound for field n°"<<i<<"in file |"<<_fileName<<"| !");
421 componentName = new char[numberOfComponents*MED_TAILLE_PNOM+1] ;
422 unitName = new char[numberOfComponents*MED_TAILLE_PNOM+1] ;
424 err = MED_FR::MEDchampInfo(_medIdt, i, fieldName, &type, componentName,
425 unitName, numberOfComponents) ;
427 MESSAGE("Champ "<<i<<" : #" << fieldName <<"# et recherche #"<<_fieldName.c_str()<<"#");
428 if ( !strcmp(fieldName,_fieldName.c_str()) ) {
429 MESSAGE("FOUND FIELD "<< fieldName <<" : "<<i);
433 // not found : release memory and search next field !
434 delete[] componentName ;
441 if (_fieldNum==MED_INVALID)
442 throw MEDEXCEPTION(LOCALIZED( STRING(LOC) << ": Field "<<_fieldName << " not found in file " << _fileName ) );
443 MESSAGE ("FieldNum : "<<_fieldNum);
446 // int NumberOfComponents = MED_FR::MEDnChamp(_medIdt,_fieldNum) ;
447 if (numberOfComponents < 1)
448 throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"no component")) ; // use iostring !
449 // test type to check if it is rigth !!!???
450 _ptrField->_numberOfComponents = numberOfComponents ;
451 _ptrField->_componentsTypes = new int[numberOfComponents] ;
452 _ptrField->_componentsNames = new string[numberOfComponents] ;
453 _ptrField->_componentsUnits = new UNIT[numberOfComponents] ;
454 _ptrField->_componentsDescriptions = new string[numberOfComponents] ;
455 _ptrField->_MEDComponentsUnits = new string[numberOfComponents] ;
456 for (int i=0; i<numberOfComponents; i++) {
457 _ptrField->_componentsTypes[i] = 1 ;
459 // PG : what about space !!!
460 _ptrField->_componentsNames[i] = string(componentName,i*MED_TAILLE_PNOM,MED_TAILLE_PNOM) ;
461 SCRUTE(_ptrField->_componentsNames[i]);
462 _ptrField->_MEDComponentsUnits[i] = string(unitName,i*MED_TAILLE_PNOM,MED_TAILLE_PNOM) ;
463 SCRUTE(_ptrField->_MEDComponentsUnits[i]);
465 delete[] componentName;
468 // read values for each geometric type in _support
469 int NumberOfTypes = _ptrField->_support->getNumberOfTypes() ;
470 const medGeometryElement *Types = _ptrField->_support->getTypes() ;
471 T ** myValues = new (T*)[NumberOfTypes] ;
472 int * NumberOfValues = new int[NumberOfTypes] ;
473 int TotalNumberOfValues = 0 ;
474 MESSAGE ("NumberOfTypes :"<< NumberOfTypes);
475 for (int i=0; i<NumberOfTypes; i++) {
476 MESSAGE ("Type["<<i+1<<"] :"<< Types[i]);
477 MESSAGE ("Entity :"<<_ptrField->_support->getEntity());
480 const_cast <char*> (_fieldName.c_str()),
481 (MED_FR::med_entite_maillage)_ptrField->_support->getEntity(),
482 (MED_FR::med_geometrie_element)Types[i],
483 _ptrField->_iterationNumber,
484 _ptrField->_orderNumber) ; // no time step ! prend en compte le nbre de pt de gauss
485 // test if NumberOfValues is the same in _support !!! TODO that !!
487 // we could allocate array
488 myValues[i] = new T[ NumberOfValues[i]*numberOfComponents ] ;
489 TotalNumberOfValues+=NumberOfValues[i] ;// diviser par le nombre de point de gauss
490 char * ProfilName = new char[MED_TAILLE_NOM+1];
491 MESSAGE ("NumberOfValues :"<< NumberOfValues[i]);
492 MESSAGE ("NumberOfComponents :"<< numberOfComponents);
493 MESSAGE ("MESH_NAME :"<< MeshName.c_str());
494 MESSAGE ("FIELD_NAME :"<< _fieldName.c_str());
495 MESSAGE ("MED_ENTITE :"<< (MED_FR::med_entite_maillage) _ptrField->_support->getEntity());
496 MESSAGE("MED_GEOM :"<<(MED_FR::med_geometrie_element)Types[i]);
497 MESSAGE("Iteration :"<<_ptrField->getIterationNumber());
498 MESSAGE("Order :"<<_ptrField->getOrderNumber());
499 _ptrField->_numberOfValues+=NumberOfValues[i]; // problem with gauss point : _numberOfValues != TotalNumberOfValues !!!!!!!
500 if ( MED_FR::MEDchampLire(_medIdt,const_cast <char*> (MeshName.c_str()),
501 const_cast <char*> (_fieldName.c_str()),
502 (unsigned char*) myValues[i],
503 MED_FR::MED_NO_INTERLACE,
506 (MED_FR::med_entite_maillage) _ptrField->_support->getEntity(),(MED_FR::med_geometrie_element)Types[i],
507 _ptrField->getIterationNumber(),
508 _ptrField->getOrderNumber()
510 // we must do some delete !!!
511 for(int j=0; j<=i;j++)
512 delete[] myValues[j];
514 delete[] NumberOfValues ;
516 delete[] _ptrField->_componentsTypes ;
517 delete[] _ptrField->_componentsNames ;
518 delete[] _ptrField->_componentsUnits ;
519 delete[] _ptrField->_componentsDescriptions ;
520 delete[] _ptrField->_MEDComponentsUnits ;
521 _ptrField->_componentsTypes = NULL ;
522 _ptrField->_componentsNames = NULL ;
523 _ptrField->_componentsUnits = NULL ;
524 _ptrField->_componentsDescriptions = NULL ;
525 _ptrField->_MEDComponentsUnits = NULL ;
526 _fieldNum = MED_INVALID ; // we have not found right field, so reset the field number
527 throw MEDEXCEPTION( LOCALIZED( STRING(LOC) <<": ERROR when read value")) ;
530 delete[] ProfilName ;
533 // probleme avec les points de gauss : voir lorsqu-il y en a (!= 1)
534 // MEDARRAY<T> * Values = new MEDARRAY<T>(_ptrField->getNumberOfComponents(),TotalNumberOfValues/_ptrField->getNumberOfComponents(),MED_EN::MED_NO_INTERLACE);
536 if (_ptrField->_value==NULL)
537 _ptrField->_value=new MEDARRAY<T>(numberOfComponents,TotalNumberOfValues,MED_EN::MED_NO_INTERLACE);
539 MEDARRAY<T> * Values = _ptrField->_value ; // create by constructor ???
540 // check if dimensions are right : inutile : c'est dans le constructeur !!!
541 //if (Values->getLeadingValue() != numberOfComponents)
542 // throw MEDEXCEPTION( LOCALIZED( STRING(LOC) <<": leading dimension are false : "<<Values->getLeadingValue()<<" and "<<numberOfComponents) ) ;
543 //if (Values->getLengthValue() != TotalNumberOfValues)
544 // throw MEDEXCEPTION( LOCALIZED( STRING(LOC) <<": length dimension are false : "<<Values->getLengthValue()<<" and "<<TotalNumberOfValues) ) ;
546 for (int i=0; i<numberOfComponents; i++) {
547 //T * ValuesT = Values->getRow(i+1) ;
549 for (int j=0; j<NumberOfTypes; j++) {
550 T * myValue = myValues[j] ;
551 int NumberOf = NumberOfValues[j] ;
552 // _ptrField->_numberOfValues+=NumberOf; // problem with gauss point : _numberOfValues != TotalNumberOfValues !!!!!!!
553 int offset = NumberOf*i ;
554 for (int k=0 ; k<NumberOf; k++) {
555 //ValuesT[Count]=myValue[k+offset] ;
556 Values->setIJ(Count,i+1,myValue[k+offset]);
558 SCRUTE(Values->getIJ(Count,i+1));
564 for (int j=0; j<NumberOfTypes; j++)
565 delete[] myValues[j] ;
567 delete[] NumberOfValues ;
569 _ptrField->_isRead = true ;
575 template <class T> void MED_FIELD_RDONLY_DRIVER<T>::write( void ) const
578 throw MEDEXCEPTION("MED_FIELD_RDONLY_DRIVER::write : Can't write with a RDONLY driver !");
581 /*--------------------- WRONLY PART -------------------------------*/
583 template <class T> GENDRIVER * MED_FIELD_WRONLY_DRIVER<T>::copy(void) const
585 MED_FIELD_WRONLY_DRIVER<T> * myDriver =
586 new MED_FIELD_WRONLY_DRIVER<T>(*this);
590 template <class T> void MED_FIELD_WRONLY_DRIVER<T>::read (void)
593 throw MEDEXCEPTION("MED_FIELD_WRONLY_DRIVER::read : Can't read with a WRONLY driver !");
596 template <class T> void MED_FIELD_WRONLY_DRIVER<T>::write(void) const
599 const char * LOC = "MED_FIELD_WRONLY_DRIVER::write(void) const " ;
601 if (_status==MED_OPENED)
605 int component_count=_ptrField->getNumberOfComponents();
606 string component_name(component_count*MED_TAILLE_PNOM,' ') ;
607 string component_unit(component_count*MED_TAILLE_PNOM,' ') ;
609 const string * listcomponent_name=_ptrField->getComponentsNames() ;
610 const string * listcomponent_unit=_ptrField->getMEDComponentsUnits() ;
612 for (int i=0; i < component_count ; i++) {
613 length = min(MED_TAILLE_PNOM,(int)listcomponent_name[i].size());
614 component_name.replace(i*MED_TAILLE_PNOM,length,
615 listcomponent_name[i],0,length);
616 length = min(MED_TAILLE_PNOM,(int)listcomponent_unit[i].size());
617 component_unit.replace(i*MED_TAILLE_PNOM,length,
618 listcomponent_unit[i],0,length);
621 MESSAGE("component_name=|"<<component_name<<"|");
622 MESSAGE("component_unit=|"<<component_unit<<"|");
624 MED_EN::med_type_champ ValueType=_ptrField->getValueType() ;
626 MESSAGE("Template Type =|"<<ValueType<<"|");
628 // le champ existe deja ???
629 char * champName = new char[MED_TAILLE_NOM+1] ;
630 MED_FR::med_type_champ type ;
634 int n = MED_FR::MEDnChamp(_medIdt,0);
636 for (int i=1; i<=n; i++) {
637 nbComp = MED_FR::MEDnChamp(_medIdt,i);
638 compName = new char[MED_TAILLE_PNOM*nbComp+1];
639 compUnit = new char[MED_TAILLE_PNOM*nbComp+1];
640 err = MED_FR::MEDchampInfo(_medIdt,i,champName,&type,compName,compUnit,nbComp);
642 if (strcmp(champName,_ptrField->getName().c_str())==0) { // Found !
652 if (nbComp != component_count)
653 throw MEDEXCEPTION( LOCALIZED (STRING(LOC)
654 <<": Field exist in file, but number of component are different : "<<nbComp<<" in file and "<<component_count<<" in memory."
657 // component name and unit
658 MESSAGE(LOC<<" Component name in file : "<<compName);
659 MESSAGE(LOC<<" Component name in memory : "<<component_name);
660 MESSAGE(LOC<<" Component unit in file : "<<compUnit);
661 MESSAGE(LOC<<" Component unit in memory : "<<component_unit);
666 // Verify the field doesn't exist
668 string dataGroupName = "/CHA/";
669 dataGroupName += _ptrField->getName();
670 MESSAGE(LOC << "|" << dataGroupName << "|" );
671 med_idt gid = H5Gopen(_medIdt, dataGroupName.c_str() );
675 err=MED_FR::MEDchampCr(_medIdt,
676 const_cast <char*> ((_ptrField->getName()).c_str()),
677 (MED_FR::med_type_champ) ValueType,
678 const_cast <char*> ( component_name.c_str() ),
679 const_cast <char*> ( component_unit.c_str() ),
682 throw MEDEXCEPTION( LOCALIZED (STRING(LOC)
683 << ": Error MEDchampCr : "<<err
690 const SUPPORT * mySupport = _ptrField->getSupport() ;
692 if (! mySupport->isOnAllElements())
693 throw MEDEXCEPTION( LOCALIZED (STRING(LOC)
694 <<": Field must be on all entity"
698 MESH * myMesh = mySupport->getMesh() ;
699 string MeshName = myMesh->getName() ;
700 //MED_EN::medModeSwitch Mode = _ptrField->_value->getMode() ;
701 // on boucle sur tout les types pour ecrire les tableaux de valeur
702 int NumberOfType = mySupport->getNumberOfTypes() ;
704 const medGeometryElement * Types = mySupport->getTypes() ;
705 const int * NumberOfGaussPoint = mySupport->getNumberOfGaussPoint() ;
706 for (int i=0;i<NumberOfType;i++) {
707 int NumberOfElements = mySupport->getNumberOfElements(Types[i]) ;
709 const T * value = _ptrField->getValueI(MED_EN::MED_FULL_INTERLACE,Index) ;
711 MESSAGE("_medIdt : "<<_medIdt);
712 MESSAGE("MeshName.c_str() : "<<MeshName.c_str());
713 MESSAGE("_ptrField->getName() : "<<_ptrField->getName());
714 MESSAGE("value : "<<value);
715 MESSAGE("NumberOfElements : "<<NumberOfElements);
716 MESSAGE("NumberOfGaussPoint[i] : "<<NumberOfGaussPoint[i]);
717 MESSAGE("mySupport->getEntity() : "<<mySupport->getEntity());
718 MESSAGE("Types[i] : "<<Types[i]);
719 MESSAGE("_ptrField->getIterationNumber() : "<<_ptrField->getIterationNumber());
720 MESSAGE("_ptrField->getTime() : "<<_ptrField->getTime());
721 MESSAGE("_ptrField->getOrderNumber() : "<<_ptrField->getOrderNumber());
723 /* char chanom[MED_TAILLE_NOM+1];
724 char chacomp[MED_TAILLE_NOM+1];
725 char chaunit[MED_TAILLE_NOM+1];
726 MED_FR::med_type_champ chatype;
729 err=MED_FR::MEDchampInfo(_medIdt,1,chanom,&chatype,chacomp,chaunit,chancomp);
733 cout<<"=======================================================================> gros probleme"<<endl;
736 cout<<"==================> nom lu = "<<chanom<<endl;
737 cout<<"==================> type lu = "<<chatype<<endl;
738 cout<<"==================> nom composante lu = "<<chacomp<<endl;
739 cout<<"==================> nom unit lu = "<<chaunit<<endl;
740 cout<<"==================> valeur de MED_FR::MED_REEL64 = "<<MED_FR::MED_REEL64<<endl;
743 err=MED_FR::MEDchampEcr(_medIdt,
744 const_cast <char*> ( MeshName.c_str()) , //( string(mesh_name).resize(MED_TAILLE_NOM).c_str())
745 const_cast <char*> ( (_ptrField->getName()).c_str()),
746 (unsigned char*)value,
747 MED_FR::MED_FULL_INTERLACE,
749 NumberOfGaussPoint[i],
752 MED_FR::MED_REMP, // PROFIL NON GERE, mode de remplacement non géré
753 (MED_FR::med_entite_maillage)mySupport->getEntity(),
754 (MED_FR::med_geometrie_element)Types[i],
755 _ptrField->getIterationNumber(),
757 _ptrField->getTime(),
758 _ptrField->getOrderNumber()
760 if (err < MED_VALID )
761 throw MEDEXCEPTION(LOCALIZED( STRING(LOC)
762 <<": Error in writing Field "<< _ptrField->getName() <<", type "<<Types[i]
766 Index += NumberOfElements ;
774 /*--------------------- RDWR PART -------------------------------*/
776 template <class T> GENDRIVER * MED_FIELD_RDWR_DRIVER<T>::copy(void) const
778 MED_FIELD_RDWR_DRIVER<T> * myDriver =
779 new MED_FIELD_RDWR_DRIVER<T>(*this);
783 template <class T> void MED_FIELD_RDWR_DRIVER<T>::write(void) const
786 BEGIN_OF("MED_FIELD_RDWR_DRIVER::write(void)");
787 MED_FIELD_WRONLY_DRIVER<T>::write();
788 END_OF("MED_FIELD_RDWR_DRIVER::write(void)");
791 template <class T> void MED_FIELD_RDWR_DRIVER<T>::read (void)
794 BEGIN_OF("MED_FIELD_RDWR_DRIVER::read(void)");
795 MED_FIELD_RDONLY_DRIVER<T>::read();
796 END_OF("MED_FIELD_RDWR_DRIVER::read(void)");
799 /*-----------------------------------------------------------------*/
801 #endif /* MED_FIELD_DRIVER_HXX */