#include "MEDMEM_STRING.hxx"
#include "MEDMEM_Exception.hxx"
#include "MEDMEM_Unit.hxx"
+#include "MEDMEM_Array.hxx"
+#include "MEDMEM_Support.hxx"
//#include "MEDMEM_Field.hxx"
+#include "MEDMEM_Mesh.hxx"
//using namespace MED_FR ;
+namespace MEDMEM {
template <class T> class FIELD;
// A QD LA CLASSE MED_ALL_ELEMENTS_DRIVER.... :) pour mutualiser le open ..... avec led _medIdt...
+
+/*!
+
+ Driver Med for FIELD.
+
+ Generic part : implement open and close methods.
+
+*/
+
template <class T> class MED_FIELD_DRIVER : public GENDRIVER
{
protected:
// static const char * const all_cell_type_tab [MED_NBR_GEOMETRIE_MAILLE];
+ /*!
+ Constructor.
+ */
MED_FIELD_DRIVER():GENDRIVER(),
_ptrField((FIELD<T> *)MED_NULL),_medIdt(MED_INVALID),
_fieldName(""),_fieldNum(MED_INVALID) {}
+ /*!
+ Constructor.
+ */
MED_FIELD_DRIVER(const string & fileName, FIELD<T> * ptrField,
med_mode_acces accessMode)
: GENDRIVER(fileName,accessMode),
_ptrField((FIELD<T> *) ptrField),_medIdt(MED_INVALID),
- _fieldName(""),_fieldNum(MED_INVALID)
+ _fieldName(fileName),_fieldNum(MED_INVALID)
{
}
-
- void open() {
+
+ /*!
+ Copy constructor.
+ */
+ MED_FIELD_DRIVER(const MED_FIELD_DRIVER & fieldDriver):
+ GENDRIVER(fieldDriver),
+ _ptrField(fieldDriver._ptrField),
+ _medIdt(MED_INVALID),
+ _fieldName(fieldDriver._fieldName),
+ _fieldNum(fieldDriver._fieldNum)
+ {
+ }
+
+ /*!
+ Destructor.
+ */
+ virtual ~MED_FIELD_DRIVER() {
+ }
+
+ void open() throw (MEDEXCEPTION)
+ {
const char * LOC = "MED_FIELD_DRIVER::open() ";
BEGIN_OF(LOC);
// we must set fieldname before open, because we must find field number in file (if it exist !!!)
+ if ( _fileName == "" )
+ throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
+ << "_fileName is |\"\"|, please set a correct fileName before calling open()"
+ )
+ );
MESSAGE(LOC<<"_fileName.c_str : "<< _fileName.c_str()<<",mode : "<< _accessMode);
_medIdt = MED_FR::MEDouvrir( (const_cast <char *> (_fileName.c_str())),(MED_FR::med_mode_acces) _accessMode);
MESSAGE(LOC<<"_medIdt : "<< _medIdt );
- if (_medIdt > 0) _status=MED_OPENED; else {
+ if (_medIdt > 0)
+ _status=MED_OPENED;
+ else {
_status = MED_INVALID;
+ _medIdt = MED_INVALID;
+ throw MED_EXCEPTION (LOCALIZED( STRING(LOC)
+ << "Can't open |" << _fileName
+ << "|, _medIdt : " << _medIdt
+ )
+ );
}
END_OF(LOC);
MED_FR::med_int err = 0;
if (_status == MED_OPENED) {
err=MED_FR::MEDfermer(_medIdt);
- H5close();
+ H5close(); // If we call H5close() all the files are closed.
_status = MED_CLOSED;
_medIdt = MED_INVALID;
MESSAGE(" MED_FIELD_DRIVER::close() : MEDfermer : _medIdt= " << _medIdt );
virtual void write( void ) const = 0 ;
virtual void read ( void ) = 0 ;
+
+ /*!
+ Set the name of the FIELD asked in file.
+
+ It could be different than the name of the FIELD object.
+ */
void setFieldName(const string & fieldName) ;
+ /*!
+ Get the name of the FIELD asked in file.
+ */
string getFieldName() const ;
+
+private:
+ virtual GENDRIVER * copy ( void ) const = 0 ;
+
};
+/*!
+
+ Driver Med for FIELD : Read only.
+
+ Implement read method.
+
+*/
+
template <class T> class MED_FIELD_RDONLY_DRIVER : public virtual MED_FIELD_DRIVER<T>
{
public :
+ /*!
+ Constructor.
+ */
MED_FIELD_RDONLY_DRIVER():MED_FIELD_DRIVER<T>() {};
+ /*!
+ Constructor.
+ */
MED_FIELD_RDONLY_DRIVER(const string & fileName, FIELD<T> * ptrField):
MED_FIELD_DRIVER<T>(fileName,ptrField,MED_RDONLY) {
BEGIN_OF("MED_FIELD_RDONLY_DRIVER::MED_FIELD_RDONLY_DRIVER(const string & fileName, const FIELD<T> * ptrField)");
END_OF("MED_FIELD_RDONLY_DRIVER::MED_FIELD_RDONLY_DRIVER(const string & fileName, const FIELD<T> * ptrField)");
}
- ~MED_FIELD_RDONLY_DRIVER() {
- BEGIN_OF("MED_FIELD_RDONLY_DRIVER::~MED_FIELD_RDONLY_DRIVER()");
- END_OF("MED_FIELD_RDONLY_DRIVER::~MED_FIELD_RDONLY_DRIVER()");
- }
+ /*!
+ Copy constructor.
+ */
+ MED_FIELD_RDONLY_DRIVER(const MED_FIELD_RDONLY_DRIVER & fieldDriver):
+ MED_FIELD_DRIVER<T>(fieldDriver) {};
+
+ /*!
+ Destructor.
+ */
+ virtual ~MED_FIELD_RDONLY_DRIVER() {};
// CREER UNE METHODE POUR LIRE LA LISTE DES MAILLAGES .....
- void write( void ) const ;
- void read ( void ) ;
+ /*!
+ Return a MEDEXCEPTION : it is the read-only driver.
+ */
+ void write( void ) const throw (MEDEXCEPTION) ;
+ /*!
+ Read FIELD in the specified file.
+ */
+ void read ( void ) throw (MEDEXCEPTION) ;
+
+private:
+ GENDRIVER * copy( void ) const ;
+
};
+/*!
+
+ Driver Med for FIELD : Write only.
+
+ Implement write method.
+
+*/
+
template <class T> class MED_FIELD_WRONLY_DRIVER : public virtual MED_FIELD_DRIVER<T> {
public :
+ /*!
+ Constructor.
+ */
MED_FIELD_WRONLY_DRIVER():MED_FIELD_DRIVER<T>() {}
+ /*!
+ Constructor.
+ */
MED_FIELD_WRONLY_DRIVER(const string & fileName, FIELD<T> * ptrField):
MED_FIELD_DRIVER<T>(fileName,ptrField,MED_WRONLY)
{
END_OF("MED_FIELD_WRONLY_DRIVER::MED_FIELD_WRONLY_DRIVER(const string & fileName, const FIELD<T> * ptrField)");
};
- ~MED_FIELD_WRONLY_DRIVER() { }
+ /*!
+ Copy constructor.
+ */
+ MED_FIELD_WRONLY_DRIVER(const MED_FIELD_WRONLY_DRIVER & fieldDriver):
+ MED_FIELD_DRIVER<T>(fieldDriver) {};
+
+ /*!
+ Destructor.
+ */
+ virtual ~MED_FIELD_WRONLY_DRIVER() {};
+
+ /*!
+ Write FIELD in the specified file.
+ */
+ void write( void ) const throw (MEDEXCEPTION) ;
+ /*!
+ Return a MEDEXCEPTION : it is the write-only driver.
+ */
+ void read ( void ) throw (MEDEXCEPTION) ;
+
+private:
+ GENDRIVER * copy( void ) const ;
- void write( void ) const ;
- void read ( void ) ;
};
+/*!
+
+ Driver Med for FIELD : Read write.
+ - Use read method from MED_FIELD_RDONLY_DRIVER
+ - Use write method from MED_FIELD_WDONLY_DRIVER
+
+*/
+
template <class T> class MED_FIELD_RDWR_DRIVER : public MED_FIELD_RDONLY_DRIVER<T>, public MED_FIELD_WRONLY_DRIVER<T> {
public :
+ /*!
+ Constructor.
+ */
MED_FIELD_RDWR_DRIVER():MED_FIELD_DRIVER<T>() {}
+ /*!
+ Constructor.
+ */
MED_FIELD_RDWR_DRIVER(const string & fileName, FIELD<T> * ptrField):
MED_FIELD_DRIVER<T>(fileName,ptrField,MED_RDWR)
{
BEGIN_OF("MED_FIELD_RDWR_DRIVER::MED_FIELD_RDWR_DRIVER(const string & fileName, const FIELD<T> * ptrField)");
+ //_accessMode = MED_RDWR ;
END_OF("MED_FIELD_RDWR_DRIVER::MED_FIELD_RDWR_DRIVER(const string & fileName, const FIELD<T> * ptrField)");
};
- ~MED_FIELD_RDWR_DRIVER() { }
+ /*!
+ Copy constructor.
+ */
+ MED_FIELD_RDWR_DRIVER(const MED_FIELD_RDWR_DRIVER & fieldDriver):
+ MED_FIELD_DRIVER<T>(fieldDriver) {};
+
+ /*!
+ Destructor.
+ */
+ ~MED_FIELD_RDWR_DRIVER() {};
+
+ /*!
+ Write FIELD in the specified file.
+ */
+ void write(void) const throw (MEDEXCEPTION) ;
+ /*!
+ Read FIELD in the specified file.
+ */
+ void read (void) throw (MEDEXCEPTION) ;
+
+private:
+ GENDRIVER * copy( void ) const ;
- void write(void) const ;
- void read (void) ;
};
+}
/*-------------------------*/
/* template implementation */
/*-------------------------*/
+using namespace MEDMEM;
/*--------------------- DRIVER PART -------------------------------*/
template <class T> void MED_FIELD_DRIVER<T>::setFieldName(const string & fieldName)
/*--------------------- RDONLY PART -------------------------------*/
+template <class T> GENDRIVER * MED_FIELD_RDONLY_DRIVER<T>::copy(void) const
+{
+ MED_FIELD_RDONLY_DRIVER<T> * myDriver =
+ new MED_FIELD_RDONLY_DRIVER<T>(*this);
+ return myDriver ;
+}
+
template <class T> void MED_FIELD_RDONLY_DRIVER<T>::read(void)
+ throw (MEDEXCEPTION)
{
const char * LOC = " MED_FIELD_RDONLY_DRIVER::read() " ;
BEGIN_OF(LOC);
_fieldNum = i ;
break ;
}
+ // not found : release memory and search next field !
+ delete[] componentName ;
+ delete[] unitName ;
}
}
// read values for each geometric type in _support
int NumberOfTypes = _ptrField->_support->getNumberOfTypes() ;
- medGeometryElement *Types = _ptrField->_support->getTypes() ;
+ const medGeometryElement *Types = _ptrField->_support->getTypes() ;
T ** myValues = new (T*)[NumberOfTypes] ;
int * NumberOfValues = new int[NumberOfTypes] ;
int TotalNumberOfValues = 0 ;
for (int i=0; i<NumberOfTypes; i++) {
MESSAGE ("Type["<<i+1<<"] :"<< Types[i]);
MESSAGE ("Entity :"<<_ptrField->_support->getEntity());
- NumberOfValues[i] =
- MEDnVal(_medIdt,
- const_cast <char*> (_fieldName.c_str()),
- (MED_FR::med_entite_maillage)_ptrField->_support->getEntity(),
- (MED_FR::med_geometrie_element)Types[i],
- _ptrField->_iterationNumber,
- _ptrField->_orderNumber) ; // no time step ! prend en compte le nbre de pt de gauss
+// NumberOfValues[i] =
+// MEDnVal(_medIdt,
+// const_cast <char*> (_fieldName.c_str()),
+// (MED_FR::med_entite_maillage)_ptrField->_support->getEntity(),
+// (MED_FR::med_geometrie_element)Types[i],
+// _ptrField->_iterationNumber,
+// _ptrField->_orderNumber) ; // no time step ! prend en compte le nbre de pt de gauss
// test if NumberOfValues is the same in _support !!! TODO that !!
// we suppose it is
// we could allocate array
+ // Be really carefull about the profil; especially the last arg of
+ // MEDnVal
+
+ NumberOfValues[i] =
+ MEDnVal(_medIdt,
+ const_cast <char*> (_fieldName.c_str()),
+ (MED_FR::med_entite_maillage)_ptrField->_support->getEntity(),
+ (MED_FR::med_geometrie_element) Types[i],
+ _ptrField->_iterationNumber, _ptrField->_orderNumber,
+ const_cast <char*> (_ptrField->_support->getMesh()->getName().c_str()),
+ MED_FR::MED_COMPACT) ;
+
myValues[i] = new T[ NumberOfValues[i]*numberOfComponents ] ;
TotalNumberOfValues+=NumberOfValues[i] ;// diviser par le nombre de point de gauss
char * ProfilName = new char[MED_TAILLE_NOM+1];
+ char * LocalGaussName = new char[MED_TAILLE_NOM+1];
MESSAGE ("NumberOfValues :"<< NumberOfValues[i]);
MESSAGE ("NumberOfComponents :"<< numberOfComponents);
MESSAGE ("MESH_NAME :"<< MeshName.c_str());
MESSAGE("MED_GEOM :"<<(MED_FR::med_geometrie_element)Types[i]);
MESSAGE("Iteration :"<<_ptrField->getIterationNumber());
MESSAGE("Order :"<<_ptrField->getOrderNumber());
- if ( MED_FR::MEDchampLire(_medIdt,const_cast <char*> (MeshName.c_str()),
- const_cast <char*> (_fieldName.c_str()),
- (unsigned char*) myValues[i],
- MED_FR::MED_NO_INTERLACE,
- MED_ALL,
- ProfilName,
- (MED_FR::med_entite_maillage) _ptrField->_support->getEntity(),(MED_FR::med_geometrie_element)Types[i],
- _ptrField->getIterationNumber(),
- _ptrField->getOrderNumber()
- ) < 0) {
+ _ptrField->_numberOfValues+=NumberOfValues[i]; // problem with gauss point : _numberOfValues != TotalNumberOfValues !!!!!!!
+
+ err = MEDchampLire(_medIdt,const_cast <char*> (MeshName.c_str()),
+ const_cast <char*> (_fieldName.c_str()),
+ (unsigned char*) myValues[i],
+ MED_FR::MED_NO_INTERLACE,MED_ALL,
+ LocalGaussName,ProfilName,
+ MED_FR::MED_NO_PFLMOD,
+ (MED_FR::med_entite_maillage) _ptrField->_support->getEntity(),(MED_FR::med_geometrie_element)Types[i],
+ _ptrField->getIterationNumber(),
+ _ptrField->getOrderNumber());
+
+ if ( err < 0) {
// we must do some delete !!!
+ for(int j=0; j<=i;j++)
+ delete[] myValues[j];
+ delete[] myValues;
+ delete[] NumberOfValues ;
+ delete[] ProfilName;
+ delete[] LocalGaussName;
+ delete[] _ptrField->_componentsTypes ;
+ delete[] _ptrField->_componentsNames ;
+ delete[] _ptrField->_componentsUnits ;
+ delete[] _ptrField->_componentsDescriptions ;
+ delete[] _ptrField->_MEDComponentsUnits ;
+ _ptrField->_componentsTypes = NULL ;
+ _ptrField->_componentsNames = NULL ;
+ _ptrField->_componentsUnits = NULL ;
+ _ptrField->_componentsDescriptions = NULL ;
+ _ptrField->_MEDComponentsUnits = NULL ;
_fieldNum = MED_INVALID ; // we have not found right field, so reset the field number
throw MEDEXCEPTION( LOCALIZED( STRING(LOC) <<": ERROR when read value")) ;
}
+ // At this time ProfilName should be MED_FR::MED_NOPFL and
+ // LocalGaussName should be MED_FR::MED_NOGAUSS
delete[] ProfilName ;
+ delete[] LocalGaussName ;
}
// allocate _value
// probleme avec les points de gauss : voir lorsqu-il y en a (!= 1)
_ptrField->_value=new MEDARRAY<T>(numberOfComponents,TotalNumberOfValues,MED_EN::MED_NO_INTERLACE);
MEDARRAY<T> * Values = _ptrField->_value ; // create by constructor ???
- // check if dimensions are right
- if (Values->getLeadingValue() != numberOfComponents)
- throw MEDEXCEPTION( LOCALIZED( STRING(LOC) <<": leading dimension are false : "<<Values->getLeadingValue()<<" and "<<numberOfComponents) ) ;
- if (Values->getLengthValue() != TotalNumberOfValues)
- throw MEDEXCEPTION( LOCALIZED( STRING(LOC) <<": length dimension are false : "<<Values->getLengthValue()<<" and "<<TotalNumberOfValues) ) ;
+ // check if dimensions are right : inutile : c'est dans le constructeur !!!
+ //if (Values->getLeadingValue() != numberOfComponents)
+ // throw MEDEXCEPTION( LOCALIZED( STRING(LOC) <<": leading dimension are false : "<<Values->getLeadingValue()<<" and "<<numberOfComponents) ) ;
+ //if (Values->getLengthValue() != TotalNumberOfValues)
+ // throw MEDEXCEPTION( LOCALIZED( STRING(LOC) <<": length dimension are false : "<<Values->getLengthValue()<<" and "<<TotalNumberOfValues) ) ;
for (int i=0; i<numberOfComponents; i++) {
- T * ValuesT = Values->getI(MED_NO_INTERLACE,i+1) ;
- int Count = 0 ;
+ //T * ValuesT = Values->getRow(i+1) ;
+ int Count = 1 ;
for (int j=0; j<NumberOfTypes; j++) {
T * myValue = myValues[j] ;
int NumberOf = NumberOfValues[j] ;
+// _ptrField->_numberOfValues+=NumberOf; // problem with gauss point : _numberOfValues != TotalNumberOfValues !!!!!!!
int offset = NumberOf*i ;
for (int k=0 ; k<NumberOf; k++) {
- ValuesT[Count]=myValue[k+offset] ;
+ //ValuesT[Count]=myValue[k+offset] ;
+ Values->setIJ(Count,i+1,myValue[k+offset]);
+ SCRUTE(Count);
+ SCRUTE(Values->getIJ(Count,i+1));
Count++;
}
}
delete[] myValues[j] ;
delete[] myValues ;
delete[] NumberOfValues ;
+
+ _ptrField->_isRead = true ;
}
+
END_OF(LOC);
}
template <class T> void MED_FIELD_RDONLY_DRIVER<T>::write( void ) const
+ throw (MEDEXCEPTION)
{
throw MEDEXCEPTION("MED_FIELD_RDONLY_DRIVER::write : Can't write with a RDONLY driver !");
}
/*--------------------- WRONLY PART -------------------------------*/
+template <class T> GENDRIVER * MED_FIELD_WRONLY_DRIVER<T>::copy(void) const
+{
+ MED_FIELD_WRONLY_DRIVER<T> * myDriver =
+ new MED_FIELD_WRONLY_DRIVER<T>(*this);
+ return myDriver ;
+}
+
template <class T> void MED_FIELD_WRONLY_DRIVER<T>::read (void)
+ throw (MEDEXCEPTION)
{
- throw MEDEXCEPTION("MED_FIELD_WRONLY_DRIVER::write : Can't read with a WRONLY driver !");
+ throw MEDEXCEPTION("MED_FIELD_WRONLY_DRIVER::read : Can't read with a WRONLY driver !");
}
template <class T> void MED_FIELD_WRONLY_DRIVER<T>::write(void) const
+ throw (MEDEXCEPTION)
{
const char * LOC = "MED_FIELD_WRONLY_DRIVER::write(void) const " ;
BEGIN_OF(LOC);
string component_name(component_count*MED_TAILLE_PNOM,' ') ;
string component_unit(component_count*MED_TAILLE_PNOM,' ') ;
- string * listcomponent_name=_ptrField->getComponentsNames() ;
- string * listcomponent_unit=_ptrField->getMEDComponentsUnits() ;
+ const string * listcomponent_name=_ptrField->getComponentsNames() ;
+ const string * listcomponent_unit=_ptrField->getMEDComponentsUnits() ;
int length ;
for (int i=0; i < component_count ; i++) {
length = min(MED_TAILLE_PNOM,(int)listcomponent_name[i].size());
MED_EN::med_type_champ ValueType=_ptrField->getValueType() ;
+ MESSAGE("Template Type =|"<<ValueType<<"|");
+
// le champ existe deja ???
char * champName = new char[MED_TAILLE_NOM+1] ;
MED_FR::med_type_champ type ;
// on boucle sur tout les types pour ecrire les tableaux de valeur
int NumberOfType = mySupport->getNumberOfTypes() ;
int Index = 1 ;
- medGeometryElement * Types = mySupport->getTypes() ;
- int * NumberOfGaussPoint = mySupport->getNumberOfGaussPoint() ;
+ const medGeometryElement * Types = mySupport->getTypes() ;
+ const int * NumberOfGaussPoint = mySupport->getNumberOfGaussPoint() ;
for (int i=0;i<NumberOfType;i++) {
int NumberOfElements = mySupport->getNumberOfElements(Types[i]) ;
- MESSAGE(" "<<_ptrField->getName());
- MESSAGE(" "<<NumberOfElements);
- MESSAGE(" "<<NumberOfGaussPoint[i]);
- MESSAGE(" "<<mySupport->getEntity());
- MESSAGE(" "<<Types[i]);
- MESSAGE(" "<<_ptrField->getIterationNumber());
- MESSAGE(" "<<_ptrField->getTime());
- MESSAGE(" "<<_ptrField->getOrderNumber());
- MESSAGE("MEDchampEcr :"<<MeshName.c_str());
+ const T * value = _ptrField->getValueI(MED_EN::MED_FULL_INTERLACE,Index) ;
- T * value = _ptrField->getValueI(MED_EN::MED_FULL_INTERLACE,Index) ;
-
- err=MED_FR::MEDchampEcr(_medIdt, const_cast <char*> ( MeshName.c_str()) , //( string(mesh_name).resize(MED_TAILLE_NOM).c_str())
+ MESSAGE("_medIdt : "<<_medIdt);
+ MESSAGE("MeshName.c_str() : "<<MeshName.c_str());
+ MESSAGE("_ptrField->getName() : "<<_ptrField->getName());
+ MESSAGE("value : "<<value);
+ MESSAGE("NumberOfElements : "<<NumberOfElements);
+ MESSAGE("NumberOfGaussPoint[i] : "<<NumberOfGaussPoint[i]);
+ MESSAGE("mySupport->getEntity() : "<<mySupport->getEntity());
+ MESSAGE("Types[i] : "<<Types[i]);
+ MESSAGE("_ptrField->getIterationNumber() : "<<_ptrField->getIterationNumber());
+ MESSAGE("_ptrField->getTime() : "<<_ptrField->getTime());
+ MESSAGE("_ptrField->getOrderNumber() : "<<_ptrField->getOrderNumber());
+
+/* char chanom[MED_TAILLE_NOM+1];
+ char chacomp[MED_TAILLE_NOM+1];
+ char chaunit[MED_TAILLE_NOM+1];
+ MED_FR::med_type_champ chatype;
+ med_int chancomp=1;
+
+ err=MED_FR::MEDchampInfo(_medIdt,1,chanom,&chatype,chacomp,chaunit,chancomp);
+
+ if (err<0)
+ {
+ cout<<"=======================================================================> gros probleme"<<endl;
+ exit(-1);
+ }
+ cout<<"==================> nom lu = "<<chanom<<endl;
+ cout<<"==================> type lu = "<<chatype<<endl;
+ cout<<"==================> nom composante lu = "<<chacomp<<endl;
+ cout<<"==================> nom unit lu = "<<chaunit<<endl;
+ cout<<"==================> valeur de MED_FR::MED_REEL64 = "<<MED_FR::MED_REEL64<<endl;
+*/
+
+// err=MED_FR::MEDchampEcr(_medIdt,
+// const_cast <char*> ( MeshName.c_str()) , //( string(mesh_name).resize(MED_TAILLE_NOM).c_str())
+// const_cast <char*> ( (_ptrField->getName()).c_str()),
+// (unsigned char*)value,
+// MED_FR::MED_FULL_INTERLACE,
+// NumberOfElements,
+// NumberOfGaussPoint[i],
+// MED_ALL,
+// MED_NOPFL,
+// MED_FR::MED_REMP, // PROFIL NON GERE, mode de remplacement non géré
+// (MED_FR::med_entite_maillage)mySupport->getEntity(),
+// (MED_FR::med_geometrie_element)Types[i],
+// _ptrField->getIterationNumber(),
+// " ",
+// _ptrField->getTime(),
+// _ptrField->getOrderNumber()
+// );
+
+ err=MED_FR::MEDchampEcr(_medIdt,
+ const_cast <char*> ( MeshName.c_str()) , //( string(mesh_name).resize(MED_TAILLE_NOM).c_str())
const_cast <char*> ( (_ptrField->getName()).c_str()),
- (unsigned char*)value, MED_FR::MED_FULL_INTERLACE,
- NumberOfElements,
- NumberOfGaussPoint[i],MED_ALL, MED_NOPFL, MED_FR::MED_REMP, // PROFIL NON GERE, mode de remplacement non géré
+ (unsigned char*)value,
+ MED_FR::MED_FULL_INTERLACE,
+ NumberOfElements*NumberOfGaussPoint[i],
+ MED_NOGAUSS, MED_ALL, MED_NOPFL,
+ MED_FR::MED_NO_PFLMOD, // PROFIL NON GERE, mode de remplacement non géré
(MED_FR::med_entite_maillage)mySupport->getEntity(),
(MED_FR::med_geometrie_element)Types[i],
- _ptrField->getIterationNumber()," ",
- _ptrField->getTime(),_ptrField->getOrderNumber()
+ _ptrField->getIterationNumber(),
+ " ",
+ _ptrField->getTime(),
+ _ptrField->getOrderNumber()
);
+
if (err < MED_VALID )
throw MEDEXCEPTION(LOCALIZED( STRING(LOC)
<<": Error in writing Field "<< _ptrField->getName() <<", type "<<Types[i]
)
);
+
Index += NumberOfElements ;
}
/*--------------------- RDWR PART -------------------------------*/
+template <class T> GENDRIVER * MED_FIELD_RDWR_DRIVER<T>::copy(void) const
+{
+ MED_FIELD_RDWR_DRIVER<T> * myDriver =
+ new MED_FIELD_RDWR_DRIVER<T>(*this);
+ return myDriver ;
+}
+
template <class T> void MED_FIELD_RDWR_DRIVER<T>::write(void) const
+ throw (MEDEXCEPTION)
{
BEGIN_OF("MED_FIELD_RDWR_DRIVER::write(void)");
MED_FIELD_WRONLY_DRIVER<T>::write();
}
template <class T> void MED_FIELD_RDWR_DRIVER<T>::read (void)
+ throw (MEDEXCEPTION)
{
BEGIN_OF("MED_FIELD_RDWR_DRIVER::read(void)");
MED_FIELD_RDONLY_DRIVER<T>::read();
END_OF("MED_FIELD_RDWR_DRIVER::read(void)");
}
-
/*-----------------------------------------------------------------*/
#endif /* MED_FIELD_DRIVER_HXX */
