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());
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 myValues[i] = new T[ NumberOfValues[i]*numberOfComponents ] ;
492 TotalNumberOfValues+=NumberOfValues[i] ;// diviser par le nombre de point de gauss
493 char * ProfilName = new char[MED_TAILLE_NOM+1];
494 MESSAGE ("NumberOfValues :"<< NumberOfValues[i]);
495 MESSAGE ("NumberOfComponents :"<< numberOfComponents);
496 MESSAGE ("MESH_NAME :"<< MeshName.c_str());
497 MESSAGE ("FIELD_NAME :"<< _fieldName.c_str());
498 MESSAGE ("MED_ENTITE :"<< (MED_FR::med_entite_maillage) _ptrField->_support->getEntity());
499 MESSAGE("MED_GEOM :"<<(MED_FR::med_geometrie_element)Types[i]);
500 MESSAGE("Iteration :"<<_ptrField->getIterationNumber());
501 MESSAGE("Order :"<<_ptrField->getOrderNumber());
502 _ptrField->_numberOfValues+=NumberOfValues[i]; // problem with gauss point : _numberOfValues != TotalNumberOfValues !!!!!!!
503 if ( MED_FR::MEDchampLire(_medIdt,const_cast <char*> (MeshName.c_str()),
504 const_cast <char*> (_fieldName.c_str()),
505 (unsigned char*) myValues[i],
506 MED_FR::MED_NO_INTERLACE,
509 (MED_FR::med_entite_maillage) _ptrField->_support->getEntity(),(MED_FR::med_geometrie_element)Types[i],
510 _ptrField->getIterationNumber(),
511 _ptrField->getOrderNumber()
513 // we must do some delete !!!
514 for(int j=0; j<=i;j++)
515 delete[] myValues[j];
517 delete[] NumberOfValues ;
519 delete[] _ptrField->_componentsTypes ;
520 delete[] _ptrField->_componentsNames ;
521 delete[] _ptrField->_componentsUnits ;
522 delete[] _ptrField->_componentsDescriptions ;
523 delete[] _ptrField->_MEDComponentsUnits ;
524 _ptrField->_componentsTypes = NULL ;
525 _ptrField->_componentsNames = NULL ;
526 _ptrField->_componentsUnits = NULL ;
527 _ptrField->_componentsDescriptions = NULL ;
528 _ptrField->_MEDComponentsUnits = NULL ;
529 _fieldNum = MED_INVALID ; // we have not found right field, so reset the field number
530 throw MEDEXCEPTION( LOCALIZED( STRING(LOC) <<": ERROR when read value")) ;
533 delete[] ProfilName ;
536 // probleme avec les points de gauss : voir lorsqu-il y en a (!= 1)
537 // MEDARRAY<T> * Values = new MEDARRAY<T>(_ptrField->getNumberOfComponents(),TotalNumberOfValues/_ptrField->getNumberOfComponents(),MED_EN::MED_NO_INTERLACE);
539 if (_ptrField->_value==NULL)
540 _ptrField->_value=new MEDARRAY<T>(numberOfComponents,TotalNumberOfValues,MED_EN::MED_NO_INTERLACE);
542 MEDARRAY<T> * Values = _ptrField->_value ; // create by constructor ???
543 // check if dimensions are right : inutile : c'est dans le constructeur !!!
544 //if (Values->getLeadingValue() != numberOfComponents)
545 // throw MEDEXCEPTION( LOCALIZED( STRING(LOC) <<": leading dimension are false : "<<Values->getLeadingValue()<<" and "<<numberOfComponents) ) ;
546 //if (Values->getLengthValue() != TotalNumberOfValues)
547 // throw MEDEXCEPTION( LOCALIZED( STRING(LOC) <<": length dimension are false : "<<Values->getLengthValue()<<" and "<<TotalNumberOfValues) ) ;
549 for (int i=0; i<numberOfComponents; i++) {
550 //T * ValuesT = Values->getRow(i+1) ;
552 for (int j=0; j<NumberOfTypes; j++) {
553 T * myValue = myValues[j] ;
554 int NumberOf = NumberOfValues[j] ;
555 // _ptrField->_numberOfValues+=NumberOf; // problem with gauss point : _numberOfValues != TotalNumberOfValues !!!!!!!
556 int offset = NumberOf*i ;
557 for (int k=0 ; k<NumberOf; k++) {
558 //ValuesT[Count]=myValue[k+offset] ;
559 Values->setIJ(Count,i+1,myValue[k+offset]);
561 SCRUTE(Values->getIJ(Count,i+1));
567 for (int j=0; j<NumberOfTypes; j++)
568 delete[] myValues[j] ;
570 delete[] NumberOfValues ;
572 _ptrField->_isRead = true ;
578 template <class T> void MED_FIELD_RDONLY_DRIVER<T>::write( void ) const
581 throw MEDEXCEPTION("MED_FIELD_RDONLY_DRIVER::write : Can't write with a RDONLY driver !");
584 /*--------------------- WRONLY PART -------------------------------*/
586 template <class T> GENDRIVER * MED_FIELD_WRONLY_DRIVER<T>::copy(void) const
588 MED_FIELD_WRONLY_DRIVER<T> * myDriver =
589 new MED_FIELD_WRONLY_DRIVER<T>(*this);
593 template <class T> void MED_FIELD_WRONLY_DRIVER<T>::read (void)
596 throw MEDEXCEPTION("MED_FIELD_WRONLY_DRIVER::read : Can't read with a WRONLY driver !");
599 template <class T> void MED_FIELD_WRONLY_DRIVER<T>::write(void) const
602 const char * LOC = "MED_FIELD_WRONLY_DRIVER::write(void) const " ;
604 if (_status==MED_OPENED)
608 int component_count=_ptrField->getNumberOfComponents();
609 string component_name(component_count*MED_TAILLE_PNOM,' ') ;
610 string component_unit(component_count*MED_TAILLE_PNOM,' ') ;
612 const string * listcomponent_name=_ptrField->getComponentsNames() ;
613 const string * listcomponent_unit=_ptrField->getMEDComponentsUnits() ;
615 for (int i=0; i < component_count ; i++) {
616 length = min(MED_TAILLE_PNOM,(int)listcomponent_name[i].size());
617 component_name.replace(i*MED_TAILLE_PNOM,length,
618 listcomponent_name[i],0,length);
619 length = min(MED_TAILLE_PNOM,(int)listcomponent_unit[i].size());
620 component_unit.replace(i*MED_TAILLE_PNOM,length,
621 listcomponent_unit[i],0,length);
624 MESSAGE("component_name=|"<<component_name<<"|");
625 MESSAGE("component_unit=|"<<component_unit<<"|");
627 MED_EN::med_type_champ ValueType=_ptrField->getValueType() ;
629 MESSAGE("Template Type =|"<<ValueType<<"|");
631 // le champ existe deja ???
632 char * champName = new char[MED_TAILLE_NOM+1] ;
633 MED_FR::med_type_champ type ;
637 int n = MED_FR::MEDnChamp(_medIdt,0);
639 for (int i=1; i<=n; i++) {
640 nbComp = MED_FR::MEDnChamp(_medIdt,i);
641 compName = new char[MED_TAILLE_PNOM*nbComp+1];
642 compUnit = new char[MED_TAILLE_PNOM*nbComp+1];
643 err = MED_FR::MEDchampInfo(_medIdt,i,champName,&type,compName,compUnit,nbComp);
645 if (strcmp(champName,_ptrField->getName().c_str())==0) { // Found !
655 if (nbComp != component_count)
656 throw MEDEXCEPTION( LOCALIZED (STRING(LOC)
657 <<": Field exist in file, but number of component are different : "<<nbComp<<" in file and "<<component_count<<" in memory."
660 // component name and unit
661 MESSAGE(LOC<<" Component name in file : "<<compName);
662 MESSAGE(LOC<<" Component name in memory : "<<component_name);
663 MESSAGE(LOC<<" Component unit in file : "<<compUnit);
664 MESSAGE(LOC<<" Component unit in memory : "<<component_unit);
669 // Verify the field doesn't exist
671 string dataGroupName = "/CHA/";
672 dataGroupName += _ptrField->getName();
673 MESSAGE(LOC << "|" << dataGroupName << "|" );
674 med_idt gid = H5Gopen(_medIdt, dataGroupName.c_str() );
678 err=MED_FR::MEDchampCr(_medIdt,
679 const_cast <char*> ((_ptrField->getName()).c_str()),
680 (MED_FR::med_type_champ) ValueType,
681 const_cast <char*> ( component_name.c_str() ),
682 const_cast <char*> ( component_unit.c_str() ),
685 throw MEDEXCEPTION( LOCALIZED (STRING(LOC)
686 << ": Error MEDchampCr : "<<err
693 const SUPPORT * mySupport = _ptrField->getSupport() ;
695 if (! mySupport->isOnAllElements())
696 throw MEDEXCEPTION( LOCALIZED (STRING(LOC)
697 <<": Field must be on all entity"
701 MESH * myMesh = mySupport->getMesh() ;
702 string MeshName = myMesh->getName() ;
703 //MED_EN::medModeSwitch Mode = _ptrField->_value->getMode() ;
704 // on boucle sur tout les types pour ecrire les tableaux de valeur
705 int NumberOfType = mySupport->getNumberOfTypes() ;
707 const medGeometryElement * Types = mySupport->getTypes() ;
708 const int * NumberOfGaussPoint = mySupport->getNumberOfGaussPoint() ;
709 for (int i=0;i<NumberOfType;i++) {
710 int NumberOfElements = mySupport->getNumberOfElements(Types[i]) ;
712 const T * value = _ptrField->getValueI(MED_EN::MED_FULL_INTERLACE,Index) ;
714 MESSAGE("_medIdt : "<<_medIdt);
715 MESSAGE("MeshName.c_str() : "<<MeshName.c_str());
716 MESSAGE("_ptrField->getName() : "<<_ptrField->getName());
717 MESSAGE("value : "<<value);
718 MESSAGE("NumberOfElements : "<<NumberOfElements);
719 MESSAGE("NumberOfGaussPoint[i] : "<<NumberOfGaussPoint[i]);
720 MESSAGE("mySupport->getEntity() : "<<mySupport->getEntity());
721 MESSAGE("Types[i] : "<<Types[i]);
722 MESSAGE("_ptrField->getIterationNumber() : "<<_ptrField->getIterationNumber());
723 MESSAGE("_ptrField->getTime() : "<<_ptrField->getTime());
724 MESSAGE("_ptrField->getOrderNumber() : "<<_ptrField->getOrderNumber());
726 /* char chanom[MED_TAILLE_NOM+1];
727 char chacomp[MED_TAILLE_NOM+1];
728 char chaunit[MED_TAILLE_NOM+1];
729 MED_FR::med_type_champ chatype;
732 err=MED_FR::MEDchampInfo(_medIdt,1,chanom,&chatype,chacomp,chaunit,chancomp);
736 cout<<"=======================================================================> gros probleme"<<endl;
739 cout<<"==================> nom lu = "<<chanom<<endl;
740 cout<<"==================> type lu = "<<chatype<<endl;
741 cout<<"==================> nom composante lu = "<<chacomp<<endl;
742 cout<<"==================> nom unit lu = "<<chaunit<<endl;
743 cout<<"==================> valeur de MED_FR::MED_REEL64 = "<<MED_FR::MED_REEL64<<endl;
746 err=MED_FR::MEDchampEcr(_medIdt,
747 const_cast <char*> ( MeshName.c_str()) , //( string(mesh_name).resize(MED_TAILLE_NOM).c_str())
748 const_cast <char*> ( (_ptrField->getName()).c_str()),
749 (unsigned char*)value,
750 MED_FR::MED_FULL_INTERLACE,
752 NumberOfGaussPoint[i],
755 MED_FR::MED_REMP, // PROFIL NON GERE, mode de remplacement non géré
756 (MED_FR::med_entite_maillage)mySupport->getEntity(),
757 (MED_FR::med_geometrie_element)Types[i],
758 _ptrField->getIterationNumber(),
760 _ptrField->getTime(),
761 _ptrField->getOrderNumber()
763 if (err < MED_VALID )
764 throw MEDEXCEPTION(LOCALIZED( STRING(LOC)
765 <<": Error in writing Field "<< _ptrField->getName() <<", type "<<Types[i]
769 Index += NumberOfElements ;
777 /*--------------------- RDWR PART -------------------------------*/
779 template <class T> GENDRIVER * MED_FIELD_RDWR_DRIVER<T>::copy(void) const
781 MED_FIELD_RDWR_DRIVER<T> * myDriver =
782 new MED_FIELD_RDWR_DRIVER<T>(*this);
786 template <class T> void MED_FIELD_RDWR_DRIVER<T>::write(void) const
789 BEGIN_OF("MED_FIELD_RDWR_DRIVER::write(void)");
790 MED_FIELD_WRONLY_DRIVER<T>::write();
791 END_OF("MED_FIELD_RDWR_DRIVER::write(void)");
794 template <class T> void MED_FIELD_RDWR_DRIVER<T>::read (void)
797 BEGIN_OF("MED_FIELD_RDWR_DRIVER::read(void)");
798 MED_FIELD_RDONLY_DRIVER<T>::read();
799 END_OF("MED_FIELD_RDWR_DRIVER::read(void)");
801 /*-----------------------------------------------------------------*/
803 #endif /* MED_FIELD_DRIVER_HXX */