1 // MED MEDMEM : MED files in memory
3 // Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License.
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 // Lesser General Public License for more details.
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 // See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
24 // File : MEDMEM_MedFieldDriver.hxx
27 #ifndef MED_FIELD_DRIVER_HXX
28 #define MED_FIELD_DRIVER_HXX
32 #include "MEDMEM_define.hxx"
34 #include "MEDMEM_GenDriver.hxx"
35 #include "utilities.h"
37 #include "MEDMEM_STRING.hxx"
38 #include "MEDMEM_Exception.hxx"
39 #include "MEDMEM_Unit.hxx"
40 #include "MEDMEM_Array.hxx"
41 #include "MEDMEM_Support.hxx"
42 //#include "MEDMEM_Field.hxx"
43 #include "MEDMEM_Mesh.hxx"
45 //using namespace MED_FR ;
47 template <class T> class FIELD;
49 // A QD LA CLASSE MED_ALL_ELEMENTS_DRIVER.... :) pour mutualiser le open ..... avec led _medIdt...
55 Generic part : implement open and close methods.
59 template <class T> class MED_FIELD_DRIVER : public GENDRIVER
64 MED_FR::med_idt _medIdt;
72 // all MED cell type ?? Classe de Définition ??
73 // static const medGeometryElement all_cell_type[MED_NBR_GEOMETRIE_MAILLE];
75 // static const char * const all_cell_type_tab [MED_NBR_GEOMETRIE_MAILLE];
80 MED_FIELD_DRIVER():GENDRIVER(),
81 _ptrField((FIELD<T> *)MED_NULL),_medIdt(MED_INVALID),
82 _fieldName(""),_fieldNum(MED_INVALID) {}
86 MED_FIELD_DRIVER(const string & fileName, FIELD<T> * ptrField,
87 med_mode_acces accessMode)
88 : GENDRIVER(fileName,accessMode),
89 _ptrField((FIELD<T> *) ptrField),_medIdt(MED_INVALID),
90 _fieldName(fileName),_fieldNum(MED_INVALID)
97 MED_FIELD_DRIVER(const MED_FIELD_DRIVER & fieldDriver):
98 GENDRIVER(fieldDriver),
99 _ptrField(fieldDriver._ptrField),
100 _medIdt(MED_INVALID),
101 _fieldName(fieldDriver._fieldName),
102 _fieldNum(fieldDriver._fieldNum)
109 virtual ~MED_FIELD_DRIVER() {
112 void open() throw (MEDEXCEPTION)
114 const char * LOC = "MED_FIELD_DRIVER::open() ";
117 // we must set fieldname before open, because we must find field number in file (if it exist !!!)
118 if ( _fileName == "" )
119 throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
120 << "_fileName is |\"\"|, please set a correct fileName before calling open()"
124 MESSAGE(LOC<<"_fileName.c_str : "<< _fileName.c_str()<<",mode : "<< _accessMode);
125 _medIdt = MED_FR::MEDouvrir( (const_cast <char *> (_fileName.c_str())),(MED_FR::med_mode_acces) _accessMode);
126 MESSAGE(LOC<<"_medIdt : "<< _medIdt );
130 _status = MED_INVALID;
131 _medIdt = MED_INVALID;
132 throw MED_EXCEPTION (LOCALIZED( STRING(LOC)
133 << "Can't open |" << _fileName
134 << "|, _medIdt : " << _medIdt
143 BEGIN_OF("MED_FIELD_DRIVER::close()");
144 MED_FR::med_int err = 0;
145 if (_status == MED_OPENED) {
146 err=MED_FR::MEDfermer(_medIdt);
147 H5close(); // If we call H5close() all the files are closed.
148 _status = MED_CLOSED;
149 _medIdt = MED_INVALID;
150 MESSAGE(" MED_FIELD_DRIVER::close() : MEDfermer : _medIdt= " << _medIdt );
151 MESSAGE(" MED_FIELD_DRIVER::close() : MEDfermer : err = " << err );
153 END_OF("MED_FIELD_DRIVER::close()");
156 virtual void write( void ) const = 0 ;
157 virtual void read ( void ) = 0 ;
160 Set the name of the FIELD asked in file.
162 It could be different than the name of the FIELD object.
164 void setFieldName(const string & fieldName) ;
166 Get the name of the FIELD asked in file.
168 string getFieldName() const ;
171 virtual GENDRIVER * copy ( void ) const = 0 ;
177 Driver Med for FIELD : Read only.
179 Implement read method.
183 template <class T> class MED_FIELD_RDONLY_DRIVER : public virtual MED_FIELD_DRIVER<T>
191 MED_FIELD_RDONLY_DRIVER():MED_FIELD_DRIVER<T>() {};
196 MED_FIELD_RDONLY_DRIVER(const string & fileName, FIELD<T> * ptrField):
197 MED_FIELD_DRIVER<T>(fileName,ptrField,MED_RDONLY) {
198 BEGIN_OF("MED_FIELD_RDONLY_DRIVER::MED_FIELD_RDONLY_DRIVER(const string & fileName, const FIELD<T> * ptrField)");
199 END_OF("MED_FIELD_RDONLY_DRIVER::MED_FIELD_RDONLY_DRIVER(const string & fileName, const FIELD<T> * ptrField)");
205 MED_FIELD_RDONLY_DRIVER(const MED_FIELD_RDONLY_DRIVER & fieldDriver):
206 MED_FIELD_DRIVER<T>(fieldDriver) {};
211 virtual ~MED_FIELD_RDONLY_DRIVER() {};
213 // CREER UNE METHODE POUR LIRE LA LISTE DES MAILLAGES .....
216 Return a MEDEXCEPTION : it is the read-only driver.
218 void write( void ) const throw (MEDEXCEPTION) ;
220 Read FIELD in the specified file.
222 void read ( void ) throw (MEDEXCEPTION) ;
225 GENDRIVER * copy( void ) const ;
231 Driver Med for FIELD : Write only.
233 Implement write method.
237 template <class T> class MED_FIELD_WRONLY_DRIVER : public virtual MED_FIELD_DRIVER<T> {
244 MED_FIELD_WRONLY_DRIVER():MED_FIELD_DRIVER<T>() {}
249 MED_FIELD_WRONLY_DRIVER(const string & fileName, FIELD<T> * ptrField):
250 MED_FIELD_DRIVER<T>(fileName,ptrField,MED_WRONLY)
252 BEGIN_OF("MED_FIELD_WRONLY_DRIVER::MED_FIELD_WRONLY_DRIVER(const string & fileName, const FIELD<T> * ptrField)");
253 END_OF("MED_FIELD_WRONLY_DRIVER::MED_FIELD_WRONLY_DRIVER(const string & fileName, const FIELD<T> * ptrField)");
259 MED_FIELD_WRONLY_DRIVER(const MED_FIELD_WRONLY_DRIVER & fieldDriver):
260 MED_FIELD_DRIVER<T>(fieldDriver) {};
265 virtual ~MED_FIELD_WRONLY_DRIVER() {};
268 Write FIELD in the specified file.
270 void write( void ) const throw (MEDEXCEPTION) ;
272 Return a MEDEXCEPTION : it is the write-only driver.
274 void read ( void ) throw (MEDEXCEPTION) ;
277 GENDRIVER * copy( void ) const ;
284 Driver Med for FIELD : Read write.
285 - Use read method from MED_FIELD_RDONLY_DRIVER
286 - Use write method from MED_FIELD_WDONLY_DRIVER
290 template <class T> class MED_FIELD_RDWR_DRIVER : public MED_FIELD_RDONLY_DRIVER<T>, public MED_FIELD_WRONLY_DRIVER<T> {
297 MED_FIELD_RDWR_DRIVER():MED_FIELD_DRIVER<T>() {}
302 MED_FIELD_RDWR_DRIVER(const string & fileName, FIELD<T> * ptrField):
303 MED_FIELD_DRIVER<T>(fileName,ptrField,MED_RDWR)
305 BEGIN_OF("MED_FIELD_RDWR_DRIVER::MED_FIELD_RDWR_DRIVER(const string & fileName, const FIELD<T> * ptrField)");
306 //_accessMode = MED_RDWR ;
307 END_OF("MED_FIELD_RDWR_DRIVER::MED_FIELD_RDWR_DRIVER(const string & fileName, const FIELD<T> * ptrField)");
313 MED_FIELD_RDWR_DRIVER(const MED_FIELD_RDWR_DRIVER & fieldDriver):
314 MED_FIELD_DRIVER<T>(fieldDriver) {};
319 ~MED_FIELD_RDWR_DRIVER() {};
322 Write FIELD in the specified file.
324 void write(void) const throw (MEDEXCEPTION) ;
326 Read FIELD in the specified file.
328 void read (void) throw (MEDEXCEPTION) ;
331 GENDRIVER * copy( void ) const ;
336 /*-------------------------*/
337 /* template implementation */
338 /*-------------------------*/
340 /*--------------------- DRIVER PART -------------------------------*/
342 template <class T> void MED_FIELD_DRIVER<T>::setFieldName(const string & fieldName)
344 _fieldName = fieldName;
347 template <class T> string MED_FIELD_DRIVER<T>::getFieldName() const
352 // template <class T> void MED_FIELD_DRIVER<T>::search_field() {
353 // const char * LOC = "template <class T> class MED_FIELD_DRIVER::search_field() :";
355 // // we search the field number !!!!
356 // if (_status==MED_OPENED)
357 // if (_fieldNum==MED_INVALID) {
359 // int numberOfFields = 0; //MED_INVALID
360 // // char fieldName[MED_TAILLE_NOM+1] = "";
361 // char fieldName[MED_TAILLE_NOM+1] ;
362 // int numberOfComponents = 0;
363 // char * componentName = (char *) MED_NULL;
364 // char * unitName = (char *) MED_NULL;
365 // MED_FR::med_type_champ type ;
366 // numberOfFields = MED_FR::MEDnChamp(_medIdt,0) ;
367 // if ( numberOfFields <= 0 )
368 // throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<": No Field found !"));
369 // for (int i=1;i<=numberOfFields;i++) {
371 // numberOfComponents = MED_FR::MEDnChamp(_medIdt,i) ;
372 // if ( numberOfComponents <= 0 )
373 // throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
374 // << "Be careful there is no compound for field n°"
375 // << i << "in file |"<<_fileName<<"| !"));
377 // componentName = new char[numberOfComponents*MED_TAILLE_PNOM+1] ;
378 // unitName = new char[numberOfComponents*MED_TAILLE_PNOM+1] ;
380 // err = MED_FR::MEDchampInfo(_medIdt, i, fieldName, &type, componentName,
381 // unitName, numberOfComponents) ;
383 // delete[] componentName ;
384 // delete[] unitName ;
385 // MESSAGE("Champ "<<i<<" : #" << fieldName <<"# et recherche #"<<_fieldName.c_str()<<"#");
386 // if ( !strcmp(fieldName,_fieldName.c_str()) ) {
387 // MESSAGE("FOUND FIELD "<< fieldName <<" : "<<i);
395 /*--------------------- RDONLY PART -------------------------------*/
397 template <class T> GENDRIVER * MED_FIELD_RDONLY_DRIVER<T>::copy(void) const
399 MED_FIELD_RDONLY_DRIVER<T> * myDriver =
400 new MED_FIELD_RDONLY_DRIVER<T>(*this);
404 template <class T> void MED_FIELD_RDONLY_DRIVER<T>::read(void)
407 const char * LOC = " MED_FIELD_RDONLY_DRIVER::read() " ;
410 if (_ptrField->_name=="")
411 _ptrField->_name = _fieldName ;
413 _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 !!!!!
415 MESSAGE("###### "<<LOC<<" fieldNameDRIVER : "<<_fieldName<<" fieldName : "<<_ptrField->_name);
417 string MeshName = _ptrField->getSupport()->getMesh()->getName() ;
419 if (_status==MED_OPENED)
425 fieldName = new char[MED_TAILLE_NOM+1] ;
427 int numberOfComponents = 0;
428 char * componentName = (char *) MED_NULL;
429 char * unitName = (char *) MED_NULL;
430 MED_FR::med_type_champ type ;
432 // we search the field number !!!!
433 if (_fieldNum==MED_INVALID) {
434 int numberOfFields = 0; //MED_INVALID
435 numberOfFields = MED_FR::MEDnChamp(_medIdt,0) ;
436 if ( numberOfFields <= 0 )
437 throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<": No Field found !"));
438 for (int i=1;i<=numberOfFields;i++) {
440 numberOfComponents = MED_FR::MEDnChamp(_medIdt,i) ;
441 if ( numberOfComponents <= 0 )
442 // throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
443 // << "Be careful there is no compound for field n°"
444 // << i << "in file |"<<_fileName<<"| !"));
445 MESSAGE(LOC<<"Be careful there is no compound for field n°"<<i<<"in file |"<<_fileName<<"| !");
447 componentName = new char[numberOfComponents*MED_TAILLE_PNOM+1] ;
448 unitName = new char[numberOfComponents*MED_TAILLE_PNOM+1] ;
450 err = MED_FR::MEDchampInfo(_medIdt, i, fieldName, &type, componentName,
451 unitName, numberOfComponents) ;
453 MESSAGE("Champ "<<i<<" : #" << fieldName <<"# et recherche #"<<_fieldName.c_str()<<"#");
454 if ( !strcmp(fieldName,_fieldName.c_str()) ) {
455 MESSAGE("FOUND FIELD "<< fieldName <<" : "<<i);
459 // not found : release memory and search next field !
460 delete[] componentName ;
467 if (_fieldNum==MED_INVALID)
468 throw MEDEXCEPTION(LOCALIZED( STRING(LOC) << ": Field "<<_fieldName << " not found in file " << _fileName ) );
469 MESSAGE ("FieldNum : "<<_fieldNum);
472 // int NumberOfComponents = MED_FR::MEDnChamp(_medIdt,_fieldNum) ;
473 if (numberOfComponents < 1)
474 throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"no component")) ; // use iostring !
475 // test type to check if it is rigth !!!???
476 _ptrField->_numberOfComponents = numberOfComponents ;
477 _ptrField->_componentsTypes = new int[numberOfComponents] ;
478 _ptrField->_componentsNames = new string[numberOfComponents] ;
479 _ptrField->_componentsUnits = new UNIT[numberOfComponents] ;
480 _ptrField->_componentsDescriptions = new string[numberOfComponents] ;
481 _ptrField->_MEDComponentsUnits = new string[numberOfComponents] ;
482 for (int i=0; i<numberOfComponents; i++) {
483 _ptrField->_componentsTypes[i] = 1 ;
485 // PG : what about space !!!
486 _ptrField->_componentsNames[i] = string(componentName,i*MED_TAILLE_PNOM,MED_TAILLE_PNOM) ;
487 SCRUTE(_ptrField->_componentsNames[i]);
488 _ptrField->_MEDComponentsUnits[i] = string(unitName,i*MED_TAILLE_PNOM,MED_TAILLE_PNOM) ;
489 SCRUTE(_ptrField->_MEDComponentsUnits[i]);
491 delete[] componentName;
494 // read values for each geometric type in _support
495 int NumberOfTypes = _ptrField->_support->getNumberOfTypes() ;
496 const medGeometryElement *Types = _ptrField->_support->getTypes() ;
497 T ** myValues = new (T*)[NumberOfTypes] ;
498 int * NumberOfValues = new int[NumberOfTypes] ;
499 int TotalNumberOfValues = 0 ;
500 MESSAGE ("NumberOfTypes :"<< NumberOfTypes);
501 for (int i=0; i<NumberOfTypes; i++) {
502 MESSAGE ("Type["<<i+1<<"] :"<< Types[i]);
503 MESSAGE ("Entity :"<<_ptrField->_support->getEntity());
506 const_cast <char*> (_fieldName.c_str()),
507 (MED_FR::med_entite_maillage)_ptrField->_support->getEntity(),
508 (MED_FR::med_geometrie_element)Types[i],
509 _ptrField->_iterationNumber,
510 _ptrField->_orderNumber) ; // no time step ! prend en compte le nbre de pt de gauss
511 // test if NumberOfValues is the same in _support !!! TODO that !!
513 // we could allocate array
514 myValues[i] = new T[ NumberOfValues[i]*numberOfComponents ] ;
515 TotalNumberOfValues+=NumberOfValues[i] ;// diviser par le nombre de point de gauss
516 char * ProfilName = new char[MED_TAILLE_NOM+1];
517 MESSAGE ("NumberOfValues :"<< NumberOfValues[i]);
518 MESSAGE ("NumberOfComponents :"<< numberOfComponents);
519 MESSAGE ("MESH_NAME :"<< MeshName.c_str());
520 MESSAGE ("FIELD_NAME :"<< _fieldName.c_str());
521 MESSAGE ("MED_ENTITE :"<< (MED_FR::med_entite_maillage) _ptrField->_support->getEntity());
522 MESSAGE("MED_GEOM :"<<(MED_FR::med_geometrie_element)Types[i]);
523 MESSAGE("Iteration :"<<_ptrField->getIterationNumber());
524 MESSAGE("Order :"<<_ptrField->getOrderNumber());
525 if ( MED_FR::MEDchampLire(_medIdt,const_cast <char*> (MeshName.c_str()),
526 const_cast <char*> (_fieldName.c_str()),
527 (unsigned char*) myValues[i],
528 MED_FR::MED_NO_INTERLACE,
531 (MED_FR::med_entite_maillage) _ptrField->_support->getEntity(),(MED_FR::med_geometrie_element)Types[i],
532 _ptrField->getIterationNumber(),
533 _ptrField->getOrderNumber()
535 // we must do some delete !!!
536 for(int j=0; j<=i;j++)
537 delete[] myValues[j];
539 delete[] NumberOfValues ;
541 delete[] _ptrField->_componentsTypes ;
542 delete[] _ptrField->_componentsNames ;
543 delete[] _ptrField->_componentsUnits ;
544 delete[] _ptrField->_componentsDescriptions ;
545 delete[] _ptrField->_MEDComponentsUnits ;
546 _ptrField->_componentsTypes = NULL ;
547 _ptrField->_componentsNames = NULL ;
548 _ptrField->_componentsUnits = NULL ;
549 _ptrField->_componentsDescriptions = NULL ;
550 _ptrField->_MEDComponentsUnits = NULL ;
551 _fieldNum = MED_INVALID ; // we have not found right field, so reset the field number
552 throw MEDEXCEPTION( LOCALIZED( STRING(LOC) <<": ERROR when read value")) ;
555 delete[] ProfilName ;
558 // probleme avec les points de gauss : voir lorsqu-il y en a (!= 1)
559 // MEDARRAY<T> * Values = new MEDARRAY<T>(_ptrField->getNumberOfComponents(),TotalNumberOfValues/_ptrField->getNumberOfComponents(),MED_EN::MED_NO_INTERLACE);
561 if (_ptrField->_value==NULL)
562 _ptrField->_value=new MEDARRAY<T>(numberOfComponents,TotalNumberOfValues,MED_EN::MED_NO_INTERLACE);
564 MEDARRAY<T> * Values = _ptrField->_value ; // create by constructor ???
565 // check if dimensions are right : inutile : c'est dans le constructeur !!!
566 //if (Values->getLeadingValue() != numberOfComponents)
567 // throw MEDEXCEPTION( LOCALIZED( STRING(LOC) <<": leading dimension are false : "<<Values->getLeadingValue()<<" and "<<numberOfComponents) ) ;
568 //if (Values->getLengthValue() != TotalNumberOfValues)
569 // throw MEDEXCEPTION( LOCALIZED( STRING(LOC) <<": length dimension are false : "<<Values->getLengthValue()<<" and "<<TotalNumberOfValues) ) ;
571 for (int i=0; i<numberOfComponents; i++) {
572 //T * ValuesT = Values->getRow(i+1) ;
574 for (int j=0; j<NumberOfTypes; j++) {
575 T * myValue = myValues[j] ;
576 int NumberOf = NumberOfValues[j] ;
577 _ptrField->_numberOfValues+=NumberOf; // problem with gauss point : _numberOfValues != TotalNumberOfValues !!!!!!!
578 int offset = NumberOf*i ;
579 for (int k=0 ; k<NumberOf; k++) {
580 //ValuesT[Count]=myValue[k+offset] ;
581 Values->setIJ(Count,i+1,myValue[k+offset]);
583 SCRUTE(Values->getIJ(Count,i+1));
589 for (int j=0; j<NumberOfTypes; j++)
590 delete[] myValues[j] ;
592 delete[] NumberOfValues ;
594 _ptrField->_isRead = true ;
600 template <class T> void MED_FIELD_RDONLY_DRIVER<T>::write( void ) const
603 throw MEDEXCEPTION("MED_FIELD_RDONLY_DRIVER::write : Can't write with a RDONLY driver !");
606 /*--------------------- WRONLY PART -------------------------------*/
608 template <class T> GENDRIVER * MED_FIELD_WRONLY_DRIVER<T>::copy(void) const
610 MED_FIELD_WRONLY_DRIVER<T> * myDriver =
611 new MED_FIELD_WRONLY_DRIVER<T>(*this);
615 template <class T> void MED_FIELD_WRONLY_DRIVER<T>::read (void)
618 throw MEDEXCEPTION("MED_FIELD_WRONLY_DRIVER::read : Can't read with a WRONLY driver !");
621 template <class T> void MED_FIELD_WRONLY_DRIVER<T>::write(void) const
624 const char * LOC = "MED_FIELD_WRONLY_DRIVER::write(void) const " ;
626 if (_status==MED_OPENED)
630 int component_count=_ptrField->getNumberOfComponents();
631 string component_name(component_count*MED_TAILLE_PNOM,' ') ;
632 string component_unit(component_count*MED_TAILLE_PNOM,' ') ;
634 const string * listcomponent_name=_ptrField->getComponentsNames() ;
635 const string * listcomponent_unit=_ptrField->getMEDComponentsUnits() ;
637 for (int i=0; i < component_count ; i++) {
638 length = min(MED_TAILLE_PNOM,(int)listcomponent_name[i].size());
639 component_name.replace(i*MED_TAILLE_PNOM,length,
640 listcomponent_name[i],0,length);
641 length = min(MED_TAILLE_PNOM,(int)listcomponent_unit[i].size());
642 component_unit.replace(i*MED_TAILLE_PNOM,length,
643 listcomponent_unit[i],0,length);
646 MESSAGE("component_name=|"<<component_name<<"|");
647 MESSAGE("component_unit=|"<<component_unit<<"|");
649 MED_EN::med_type_champ ValueType=_ptrField->getValueType() ;
651 // le champ existe deja ???
652 char * champName = new char[MED_TAILLE_NOM+1] ;
653 MED_FR::med_type_champ type ;
657 int n = MED_FR::MEDnChamp(_medIdt,0);
659 for (int i=1; i<=n; i++) {
660 nbComp = MED_FR::MEDnChamp(_medIdt,i);
661 compName = new char[MED_TAILLE_PNOM*nbComp+1];
662 compUnit = new char[MED_TAILLE_PNOM*nbComp+1];
663 err = MED_FR::MEDchampInfo(_medIdt,i,champName,&type,compName,compUnit,nbComp);
665 if (strcmp(champName,_ptrField->getName().c_str())==0) { // Found !
675 if (nbComp != component_count)
676 throw MEDEXCEPTION( LOCALIZED (STRING(LOC)
677 <<": Field exist in file, but number of component are different : "<<nbComp<<" in file and "<<component_count<<" in memory."
680 // component name and unit
681 MESSAGE(LOC<<" Component name in file : "<<compName);
682 MESSAGE(LOC<<" Component name in memory : "<<component_name);
683 MESSAGE(LOC<<" Component unit in file : "<<compUnit);
684 MESSAGE(LOC<<" Component unit in memory : "<<component_unit);
689 // Verify the field doesn't exist
691 string dataGroupName = "/CHA/";
692 dataGroupName += _ptrField->getName();
693 MESSAGE(LOC << "|" << dataGroupName << "|" );
694 med_idt gid = H5Gopen(_medIdt, dataGroupName.c_str() );
698 err=MED_FR::MEDchampCr(_medIdt,
699 const_cast <char*> ((_ptrField->getName()).c_str()),
700 (MED_FR::med_type_champ) ValueType,
701 const_cast <char*> ( component_name.c_str() ),
702 const_cast <char*> ( component_unit.c_str() ),
705 throw MEDEXCEPTION( LOCALIZED (STRING(LOC)
706 << ": Error MEDchampCr : "<<err
713 const SUPPORT * mySupport = _ptrField->getSupport() ;
715 if (! mySupport->isOnAllElements())
716 throw MEDEXCEPTION( LOCALIZED (STRING(LOC)
717 <<": Field must be on all entity"
721 MESH * myMesh = mySupport->getMesh() ;
722 string MeshName = myMesh->getName() ;
723 //MED_EN::medModeSwitch Mode = _ptrField->_value->getMode() ;
724 // on boucle sur tout les types pour ecrire les tableaux de valeur
725 int NumberOfType = mySupport->getNumberOfTypes() ;
727 const medGeometryElement * Types = mySupport->getTypes() ;
728 const int * NumberOfGaussPoint = mySupport->getNumberOfGaussPoint() ;
729 for (int i=0;i<NumberOfType;i++) {
730 int NumberOfElements = mySupport->getNumberOfElements(Types[i]) ;
732 MESSAGE(" "<<_ptrField->getName());
733 MESSAGE(" "<<NumberOfElements);
734 MESSAGE(" "<<NumberOfGaussPoint[i]);
735 MESSAGE(" "<<mySupport->getEntity());
736 MESSAGE(" "<<Types[i]);
737 MESSAGE(" "<<_ptrField->getIterationNumber());
738 MESSAGE(" "<<_ptrField->getTime());
739 MESSAGE(" "<<_ptrField->getOrderNumber());
740 MESSAGE("MEDchampEcr :"<<MeshName.c_str());
742 const T * value = _ptrField->getValueI(MED_EN::MED_FULL_INTERLACE,Index) ;
744 err=MED_FR::MEDchampEcr(_medIdt, 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, MED_FR::MED_FULL_INTERLACE,
748 NumberOfGaussPoint[i],MED_ALL, MED_NOPFL, MED_FR::MED_REMP, // PROFIL NON GERE, mode de remplacement non géré
749 (MED_FR::med_entite_maillage)mySupport->getEntity(),
750 (MED_FR::med_geometrie_element)Types[i],
751 _ptrField->getIterationNumber()," ",
752 _ptrField->getTime(),_ptrField->getOrderNumber()
754 if (err < MED_VALID )
755 throw MEDEXCEPTION(LOCALIZED( STRING(LOC)
756 <<": Error in writing Field "<< _ptrField->getName() <<", type "<<Types[i]
759 Index += NumberOfElements ;
767 /*--------------------- RDWR PART -------------------------------*/
769 template <class T> GENDRIVER * MED_FIELD_RDWR_DRIVER<T>::copy(void) const
771 MED_FIELD_RDWR_DRIVER<T> * myDriver =
772 new MED_FIELD_RDWR_DRIVER<T>(*this);
776 template <class T> void MED_FIELD_RDWR_DRIVER<T>::write(void) const
779 BEGIN_OF("MED_FIELD_RDWR_DRIVER::write(void)");
780 MED_FIELD_WRONLY_DRIVER<T>::write();
781 END_OF("MED_FIELD_RDWR_DRIVER::write(void)");
784 template <class T> void MED_FIELD_RDWR_DRIVER<T>::read (void)
787 BEGIN_OF("MED_FIELD_RDWR_DRIVER::read(void)");
788 MED_FIELD_RDONLY_DRIVER<T>::read();
789 END_OF("MED_FIELD_RDWR_DRIVER::read(void)");
792 /*-----------------------------------------------------------------*/
794 #endif /* MED_FIELD_DRIVER_HXX */