SALOME::SenderInt getSenderForNumberIndex()
raises (SALOME::SALOME_Exception);
- /*!
- Returns the number of Gauss points for this %medGeometryElement.
-
- \note
- - Not defined if %SUPPORT is on MED_NODE.
- - Not defined for MED_ALL_ELEMENTS %medGeometryElement type.
- */
- long getNumberOfGaussPoint(in medGeometryElement geomElement)
- raises (SALOME::SALOME_Exception);
-
- SALOME_MED::long_array getNumbersOfGaussPoint()
- raises (SALOME::SALOME_Exception);
-
void getBoundaryElements()
raises (SALOME::SALOME_Exception);
/*!
new_group->setEntity(groupe_entity);
new_group->setAll(mailleSet.size() == maillage.size());
- vector<int> nbGaussPnt( nb_geometric_types, 1 );
- new_group->setNumberOfGaussPoint( &nbGaussPnt[0] );
-
vect_group->push_back(new_group);
delete [] tab_types_geometriques;
Find = build(MED_FACE,MEDArrayFaceFamily) ;
}
}
-
+
// on edge ?
if (!Find) {
if ((_mesh->existConnectivity(MED_NODAL,MED_EDGE))|(_mesh->existConnectivity(MED_DESCENDING,MED_EDGE))) {
_numberOfGeometricType = 0 ;
_isOnAllElts = false ;
MESSAGE ("FAMILY() : No entity found !") ;
- }
- // already done by support !!!!
-// else { // set gauss point number to be equal one !
-// _numberOfGaussPoint = new int[_numberOfGeometricType] ;
-// for (int i=0; i<_numberOfGeometricType; i++)
-// _numberOfGaussPoint[i]=1 ;
-// }
-
+ }
MESSAGE("Well now ??? :::");
}
} else
MESSAGE("Is on all entities !");
-
+
};
}
FIELD_::~FIELD_()
-{
+{
MESSAGE("~FIELD_()");
if ( _componentsTypes !=NULL)
delete[] _componentsTypes ;
throw MEDEXCEPTION(diagnosis.c_str());
}
- const int* nbGauss=getSupport()->getNumberOfGaussPoint();
- for (int i=0; i<getSupport()->getNumberOfTypes(); ++i)
- if(nbGauss[i]!=1)
- {
- diagnosis="Cannot compute Lnorm of "+getName()+
- " : Gauss numbers greater than one are not yet implemented!";
- throw MEDEXCEPTION(diagnosis.c_str());
- }
+ if (getGaussPresence() ) {
+ diagnosis="Cannot compute Lnorm of "+getName()+
+ " : Gauss numbers greater than one are not yet implemented!";
+ throw MEDEXCEPTION(diagnosis.c_str());
+ }
if(support_volume) // if the user has supplied the volume
{
#define FIELD_HXX
#include <vector>
+#include <map>
#include <algorithm>
#include <math.h>
#include <cmath>
#include "MEDMEM_nArray.hxx"
#include "MEDMEM_GenDriver.hxx"
#include "MEDMEM_ArrayInterface.hxx"
+#include "MEDMEM_SetInterlacingType.hxx"
#include "MEDMEM_FieldForward.hxx"
+#include "MEDMEM_GaussLocalization.hxx"
/*!
template < > struct SET_VALUE_TYPE<int> {
static const MED_EN::med_type_champ _valueType = MED_EN::MED_INT32; };
- template < typename T > struct SET_INTERLACING_TYPE {
- static const MED_EN::medModeSwitch _interlacingType = MED_EN::MED_UNDEFINED_INTERLACE; };
- template < > struct SET_INTERLACING_TYPE<FullInterlace>{
- static const MED_EN::medModeSwitch _interlacingType = MED_EN::MED_FULL_INTERLACE; };
- template < > struct SET_INTERLACING_TYPE<NoInterlace> {
- static const MED_EN::medModeSwitch _interlacingType = MED_EN::MED_NO_INTERLACE; };
-
class FIELD_ // GENERIC POINTER TO a template <class T, class INTERLACING_TAG> class FIELD
-{ // ùpihjpmoçhmpç_hmù
+{
protected:
bool _isRead ;
/*!
\if developper
Number of field's values.
+ doesn't take care of _numberOfComponents
+ and number of Gauss points.
\endif
*/
int _numberOfValues ;
friend class MED_MED_RDONLY_DRIVER22;
friend class MED_MED_WRONLY_DRIVER22;
friend class MED_MED_RDWR_DRIVER22;
-
friend class VTK_MED_DRIVER;
/*!
virtual int addDriver( GENDRIVER & driver);
virtual void read (const GENDRIVER &);
virtual void read(int index=0);
- virtual void openAppend( void );
+ virtual void openAppend( void );
virtual void write(const GENDRIVER &);
virtual void write(int index=0, const string & driverName="");
typedef typename MEDMEM_ArrayInterface<T,INTERLACING_TAG,Gauss>::Array ArrayGauss;
typedef typename MEDMEM_ArrayInterface<T,NoInterlace,NoGauss>::Array ArrayNo;
typedef typename MEDMEM_ArrayInterface<T,FullInterlace,NoGauss>::Array ArrayFull;
- typedef MEDMEM_Array_ Array;
+ typedef MEDMEM_Array_ Array;
+ typedef T ElementType;
+ typedef INTERLACING_TAG InterlacingTag;
+ typedef map<MED_EN::medGeometryElement,GAUSS_LOCALIZATION_*> locMap;
// array of value of type T
Array *_value ;
+ map<MED_EN::medGeometryElement,GAUSS_LOCALIZATION_*> _gaussModel; //A changer quand les drivers seront template de l'entrelacement
+
static T _scalarForPow;
static T pow(T x);
inline const T* getRow(int i) const throw (MEDEXCEPTION);
inline const T* getColumn(int j) const throw (MEDEXCEPTION);
inline T getValueIJ(int i,int j) const throw (MEDEXCEPTION);
+ inline T getValueIJK(int i,int j,int k) const throw (MEDEXCEPTION);
+
bool getValueOnElement(int eltIdInSup,T* retValues) const throw (MEDEXCEPTION);
+ const int getNumberOfGeometricTypes() const throw (MEDEXCEPTION);
+ const GAUSS_LOCALIZATION<INTERLACING_TAG> & getGaussLocalization(MED_EN::medGeometryElement geomElement) const throw (MEDEXCEPTION);
+ const int * getNumberOfGaussPoints() const throw (MEDEXCEPTION);
+ const int getNumberOfGaussPoints( MED_EN::medGeometryElement geomElement) const throw (MEDEXCEPTION);
+ const int getNbGaussI(int i) const throw (MEDEXCEPTION);
+ const int * getNumberOfElements() const throw (MEDEXCEPTION);
+ const MED_EN::medGeometryElement * getGeometricTypes() const throw (MEDEXCEPTION);
+ bool isOnAllElements() const throw (MEDEXCEPTION);
+
inline void setArray(MEDMEM_Array_ *value) throw (MEDEXCEPTION);
inline void setValue( T* value) throw (MEDEXCEPTION);
inline void setRow( int i, T* value) throw (MEDEXCEPTION);
{
MESSAGE("Constructeur FIELD de recopie");
- // RECOPIE PROFOND Rmq from EF
+ // RECOPIE PROFONDE <> de l'operateur= Rmq from EF
if (m._value != NULL)
{
if ( m.getGaussPresence() )
}
else
_value = (ArrayNoGauss *) NULL;
+ locMap::const_iterator it;
+ for ( it = m._gaussModel.begin();it != m._gaussModel.end(); it++ )
+ _gaussModel[dynamic_cast<const GAUSS_LOCALIZATION<INTERLACING_TAG> * > ((*it).second)->getType()]=
+ new GAUSS_LOCALIZATION<INTERLACING_TAG>(
+ *dynamic_cast<const GAUSS_LOCALIZATION<INTERLACING_TAG> * > ( (*it).second )
+ );
_valueType = m._valueType;
_interlacingType = m._interlacingType;
_value = m._value; //PROBLEME RECOPIE DES POINTEURS PAS COHERENT AVEC LE
//CONSTRUCTEUR PAR RECOPIE
- //CF :Commentaire dans MEDMEM_Array
+ //CF :Commentaire dans MEDMEM_Array
+ locMap::const_iterator it;
+ for ( it = m._gaussModel.begin();it != m._gaussModel.end(); it++ )
+ _gaussModel[dynamic_cast<const GAUSS_LOCALIZATION<INTERLACING_TAG> * > ((*it).second)->getType()]=
+ new GAUSS_LOCALIZATION<INTERLACING_TAG>(
+ *dynamic_cast<const GAUSS_LOCALIZATION<INTERLACING_TAG> * > ( (*it).second )
+ );
+
_valueType = m._valueType;
_interlacingType = m._interlacingType;
+
+ return *this;
}
/*!
const FIELD<double, FullInterlace> * p_field_size=p_field_volume;
if(!p_field_volume) // if the user don't supply the volume
- p_field_size=_getFieldSize(); // we calculate the volume [PROVISOIRE, en attendant l'implémentation dans mesh]
+ p_field_size=_getFieldSize(); // we calculate the volume [PROVISOIRE, en attendant l'implémentation dans mesh]
// get pointer to the element's volumes. MED_FULL_INTERLACE is the default mode for p_field_size
const double* vol=p_field_size->getValue();
// Il n'est vraiment pas optimal de mixer des champs dans des modes d'entrelacement
// different juste pour le calcul
-
+
const T * value = NULL;
ArrayNo * myArray = NULL;
if ( getInterlacingType() == MED_EN::MED_NO_INTERLACE )
provides the meshName related mesh but doesn't not set a mesh in the created
support.
*/
-template <class T, class INTERLACING_TAG>
+template <class T, class INTERLACING_TAG>
FIELD<T,INTERLACING_TAG>::FIELD(driverTypes driverType,
const string & fileName,
const string & fieldDriverName,
BEGIN_OF(" Destructeur FIELD<T, INTERLACING_TAG>::~FIELD()");
SCRUTE(this);
if (_value) delete _value;
+ locMap::const_iterator it;
+ for ( it = _gaussModel.begin();it != _gaussModel.end(); it++ )
+ delete (*it).second;
+
END_OF(" Destructeur FIELD<T,INTERLACING_TAG>::~FIELD()");
}
_numberOfValues = _support->getNumberOfElements(MED_EN::MED_ALL_ELEMENTS);
MESSAGE(LOC <<" : "<<_numberOfValues <<" et "<< NumberOfComponents);
- //EF : A modifier lors de l'intégration de la classe de localisation des points de gauss
+ //EF : A modifier lors de l'intégration de la classe de localisation des points de gauss
_value = new ArrayNoGauss(_numberOfComponents,_numberOfValues);
_isRead = true ;
MESSAGE("FIELD : constructeur : "<<LengthValue <<" et "<< NumberOfComponents);
_numberOfValues = LengthValue ;
- //EF : A modifier lors de l'intégration de la classe de localisation des points de gauss
+ //EF : A modifier lors de l'intégration de la classe de localisation des points de gauss
_value = new ArrayNoGauss(_numberOfComponents,_numberOfValues);
_isRead = true ;
bool FIELD<T, INTERLACING_TAG>::getValueOnElement(int eltIdInSup,T* retValues)
const throw (MEDEXCEPTION)
{
-// retValues = getRow(eltIdInSup);
if(eltIdInSup<1)
return false;
END_OF(LOC);
return _value ;
}
-template <class T,class INTERLACING_TAG> inline
+template <class T,class INTERLACING_TAG> inline
typename MEDMEM_ArrayInterface<T,INTERLACING_TAG,Gauss>::Array *
FIELD<T, INTERLACING_TAG>::getArrayGauss() const throw (MEDEXCEPTION)
{
}
-template <class T,class INTERLACING_TAG> inline
+template <class T,class INTERLACING_TAG> inline
typename MEDMEM_ArrayInterface<T,INTERLACING_TAG,NoGauss>::Array *
FIELD<T, INTERLACING_TAG>::getArrayNoGauss() const throw (MEDEXCEPTION)
{
FIELD<T, INTERLACING_TAG>::getGaussPresence() const throw (MEDEXCEPTION)
{
const char * LOC = "FIELD<T, INTERLACING_TAG>::getGaussPresence() const :";
- BEGIN_OF(LOC);
+ //BEGIN_OF(LOC);
if (_value != NULL)
return _value->getGaussPresence();
else
throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"Can't call getGaussPresence on a null _value"));
- END_OF(LOC);
+ //END_OF(LOC);
}
/*!
Return the actual length of the reference to values array returned by getValue.
+ Take care of number of components and number of Gauss points by geometric type
*/
template <class T, class INTERLACING_TAG>
inline int FIELD<T, INTERLACING_TAG>::getValueLength() const
throw (MEDEXCEPTION)
{
- // be carefull about number of gauss point
- return _numberOfComponents*_numberOfValues;
+ if ( getGaussPresence() )
+ return dynamic_cast<ArrayGauss *>(_value)->getArraySize() ;
+ else
+ return dynamic_cast<ArrayNoGauss *>(_value)->getArraySize() ;
}
/*!
of FIELD values array.
If a faster accessor is intended you may use getArray() once,
then MEDMEM_Array accessors.
- Be careful if field support is not on all elements you might
- have to use support->getValIndFromGlobalNumber(i).
+ Be careful if field support is not on all elements getRow
+ use support->getValIndFromGlobalNumber(i).
*/
template <class T,class INTERLACING_TAG> inline
const T*
FIELD<T,INTERLACING_TAG>::getRow(int i) const throw (MEDEXCEPTION)
{
const char * LOC = "FIELD<T,INTERLACING_TAG>::getRow(int i) : ";
- BEGIN_OF(LOC);
+ //BEGIN_OF(LOC);
int valIndex=-1;
if (_support)
else
throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"Support not define |" ));
+ //cout << endl << "getRow Valindex : " << valIndex << endl;
if ( getGaussPresence() )
- return
dynamic_cast<ArrayGauss *>(_value)->getRow(valIndex) ;
+ return
static_cast<ArrayGauss *>(_value)->getRow(valIndex) ;
else
- return
dynamic_cast<ArrayNoGauss *>(_value)->getRow(valIndex) ;
- END_OF(LOC);
+ return
static_cast<ArrayNoGauss *>(_value)->getRow(valIndex) ;
+ //END_OF(LOC);
}
/*!
FIELD<T,INTERLACING_TAG>::getColumn(int j) const throw (MEDEXCEPTION)
{
const char * LOC ="FIELD<T,INTERLACING_TAG>::getColumn(int j) : ";
- BEGIN_OF(LOC);
+ //BEGIN_OF(LOC);
if ( getGaussPresence() )
- return
dynamic_cast<ArrayGauss *>(_value)->getColumn(j) ;
+ return
static_cast<ArrayGauss *>(_value)->getColumn(j) ;
else
- return
dynamic_cast<ArrayNoGauss *>(_value)->getColumn(j) ;
+ return
static_cast<ArrayNoGauss *>(_value)->getColumn(j) ;
}
/*!
template <class T,class INTERLACING_TAG> inline T FIELD<T,INTERLACING_TAG>::getValueIJ(int i,int j) const throw (MEDEXCEPTION)
{
const char * LOC = "getValueIJ(..)";
- BEGIN_OF(LOC);
+ //BEGIN_OF(LOC);
int valIndex=-1;
if (_support)
valIndex = _support->getValIndFromGlobalNumber(i);
else
- throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"Support not define |" ));
+ throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"Support not defined" ));
if ( getGaussPresence() )
- return dynamic_cast<ArrayGauss *>(_value)->getIJ(valIndex,j) ;
+ return static_cast<ArrayGauss *>(_value)->getIJ(valIndex,j) ;
+ else
+ return static_cast<ArrayNoGauss *>(_value)->getIJ(valIndex,j) ;
+}
+
+/*!
+ Return the j^{th} component of k^{th} gauss points of i^{th} value.
+*/
+template <class T,class INTERLACING_TAG> inline T FIELD<T,INTERLACING_TAG>::getValueIJK(int i,int j,int k) const throw (MEDEXCEPTION)
+{
+ const char * LOC = "getValueIJK(..)";
+ //BEGIN_OF(LOC);
+ int valIndex=-1;
+ if (_support)
+ valIndex = _support->getValIndFromGlobalNumber(i);
+ else
+ throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"Support not defined" ));
+
+ if ( getGaussPresence() )
+ return static_cast<ArrayGauss *>(_value)->getIJK(valIndex,j,k) ;
+ else
+ return static_cast<ArrayNoGauss *>(_value)->getIJK(valIndex,j,k) ;
+}
+
+
+template <class T,class INTERLACING_TAG> const int FIELD<T,INTERLACING_TAG>::getNumberOfGeometricTypes() const throw (MEDEXCEPTION)
+{
+ const char * LOC = "getNumberOfGeometricTypes(..)";
+ BEGIN_OF(LOC);
+ if (_support)
+ return _support->getNumberOfTypes();
+ else
+ throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"Support not defined" ));
+ END_OF(LOC);
+};
+
+
+template <class T,class INTERLACING_TAG> const GAUSS_LOCALIZATION<INTERLACING_TAG> &
+FIELD<T,INTERLACING_TAG>::getGaussLocalization(MED_EN::medGeometryElement geomElement) const throw (MEDEXCEPTION)
+{
+ const char * LOC ="getGaussLocalization(MED_EN::medGeometryElement geomElement) : ";
+ const GAUSS_LOCALIZATION_ * locPtr=0;
+
+ locMap::const_iterator it;
+ if ( ( it = _gaussModel.find(geomElement)) != _gaussModel.end() ) {
+ locPtr = (*it).second;
+ return *static_cast<const GAUSS_LOCALIZATION<INTERLACING_TAG> *>(locPtr);
+ }
+ else
+ throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"Can't find any GaussLocalization on this geometric type" ));
+
+};
+
+/*!
+ Returns number of Gauss points for this medGeometryElement.
+
+ Note :
+ if there is no GAUSS_LOCALIZATION having this medGeometryElement but
+ the medGeometryElement exist in the SUPPORT, getNumberOfGaussPoints
+ return 1
+*/
+template <class T,class INTERLACING_TAG> const int FIELD<T,INTERLACING_TAG>::getNumberOfGaussPoints(MED_EN::medGeometryElement geomElement) const
+ throw (MEDEXCEPTION)
+{
+ const char * LOC ="getNumberOfGaussPoints(MED_EN::medGeometryElement geomElement) : ";
+ const GAUSS_LOCALIZATION_ * locPtr=0;
+
+ locMap::const_iterator it;
+ if ( ( it = _gaussModel.find(geomElement)) != _gaussModel.end() ) {
+ locPtr = (*it).second;
+ return static_cast<const GAUSS_LOCALIZATION<INTERLACING_TAG> *>(locPtr)->getNbGauss();
+ }
else
- return dynamic_cast<ArrayNoGauss *>(_value)->getIJ(valIndex,j) ;
+ if (_support)
+ try {
+ if ( _support->getNumberOfElements(geomElement) ) return 1;
+ } catch ( MEDEXCEPTION & ex) {
+ throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<< "GeometricType not found !" )) ;
+ }
+ else
+ throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"Support not defined" ));
+
+ throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"Should never execute this!" ));
+
+}
+
+/*!
+ Returns number of Gauss points for each geometric type.
+
+ Note :
+ if there is no gauss points whatever the geometric type is
+ it returns an exception. (renvoyer un tableau de 1 ?)
+*/
+template <class T,class INTERLACING_TAG> const int * FIELD<T,INTERLACING_TAG>::getNumberOfGaussPoints() const
+ throw (MEDEXCEPTION)
+{
+ const char * LOC ="const int * getNumberOfGaussPoints(MED_EN::medGeometryElement geomElement) : ";
+
+ if (_value)
+ if ( getGaussPresence() ) {
+ return dynamic_cast<ArrayGauss *>(_value)->getNbGaussGeo()+1;
+ } else
+ throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"value hasn't Gauss points " ));
+
+ else
+ throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"Value not defined" ));
}
+/*!
+ Returns number of Gauss points for element n°i.
+ The i index is a global index (take care of previous element
+ on different geometric type).
+*/
+template <class T,class INTERLACING_TAG> const int FIELD<T,INTERLACING_TAG>::getNbGaussI(int i) const throw (MEDEXCEPTION)
+{
+ const char * LOC = "getNbGaussI(..)";
+// BEGIN_OF(LOC);
+
+ int valIndex=-1;
+ if (_support)
+ valIndex = _support->getValIndFromGlobalNumber(i);
+ else
+ throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"Support not defined" ));
+
+ if (_value)
+ if ( getGaussPresence() )
+ return static_cast<ArrayGauss *>(_value)->getNbGauss(valIndex) ;
+ else
+ return static_cast<ArrayNoGauss *>(_value)->getNbGauss(valIndex) ;
+ else
+ throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"_value not defined" ));
+// END_OF(LOC);
+};
+
+template <class T,class INTERLACING_TAG> const int * FIELD<T,INTERLACING_TAG>::getNumberOfElements() const throw (MEDEXCEPTION)
+{
+ const char * LOC = "getNumberOfElements(..)";
+ BEGIN_OF(LOC);
+ if (_support)
+ return _support->getNumberOfElements();
+ else
+ throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"Support not defined" ));
+ END_OF(LOC);
+};
+
+template <class T,class INTERLACING_TAG> const MED_EN::medGeometryElement * FIELD<T,INTERLACING_TAG>::getGeometricTypes() const throw (MEDEXCEPTION)
+{
+ const char * LOC = "getGeometricTypes(..)";
+ BEGIN_OF(LOC);
+ if (_support)
+ return _support->getTypes();
+ else
+ throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"Support not defined" ));
+ END_OF(LOC);
+};
+template <class T,class INTERLACING_TAG> bool FIELD<T,INTERLACING_TAG>::isOnAllElements() const throw (MEDEXCEPTION)
+{
+ const char * LOC = "isOnAllElements(..)";
+ BEGIN_OF(LOC);
+ if (_support)
+ return _support->isOnAllElements();
+ else
+ throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"Support not defined" ));
+ END_OF(LOC);
+};
+
+
/*!
Copy new values array in FIELD according to the given mode.
according to specified mode.
*/
template <class T,class INTERLACING_TAG>
-inline void FIELD<T,INTERLACING_TAG>::setRow( int i, T* value) throw (MEDEXCEPTION)
+inline void FIELD<T,INTERLACING_TAG>::setRow( int i, T* value) throw (MEDEXCEPTION)
{
const char * LOC = "FIELD<T,INTERLACING_TAG>::setRow(int i, T* value) : ";
int valIndex=i;
-// JE (NB) NE SUIS PAS SUR DE CA ????
if (_support)
valIndex = _support->getValIndFromGlobalNumber(i);
else
throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"Support not define |" ));
if ( getGaussPresence() )
- return
dynamic_cast<ArrayGauss *>(_value)->setRow(valIndex, value) ;
+ return
static_cast<ArrayGauss *>(_value)->setRow(valIndex, value) ;
else
- return
dynamic_cast<ArrayNoGauss *>(_value)->setRow(valIndex, value) ;
+ return
static_cast<ArrayNoGauss *>(_value)->setRow(valIndex, value) ;
}
/*!
according to specified mode.
*/
template <class T,class INTERLACING_TAG>
-inline void FIELD<T,INTERLACING_TAG>::setColumn( int i, T* value) throw (MEDEXCEPTION)
+inline void FIELD<T,INTERLACING_TAG>::setColumn( int j, T* value) throw (MEDEXCEPTION)
{
if ( getGaussPresence() )
- return dynamic_cast<ArrayGauss *>(_value)->setColumn(i, value) ;
+ return static_cast<ArrayGauss *>(_value)->setColumn(j, value) ;
else
- return dynamic_cast<ArrayNoGauss *>(_value)->setColumn(i, value) ;
+ return static_cast<ArrayNoGauss *>(_value)->setColumn(j, value) ;
}
/*!
throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"Support not define |" ));
if ( getGaussPresence() )
- return
dynamic_cast<ArrayGauss *>(_value)->setIJ(valIndex,j,value) ;
+ return
static_cast<ArrayGauss *>(_value)->setIJ(valIndex,j,value) ;
else
- return
dynamic_cast<ArrayNoGauss *>(_value)->setIJ(valIndex,j,value) ;
+ return
static_cast<ArrayNoGauss *>(_value)->setIJ(valIndex,j,value) ;
}
/*
#include "MEDMEM_ArrayConvert.hxx"
namespace MEDMEM {
+class FIELD_;
template <class T> FIELD<T,FullInterlace> *
FieldConvert(const FIELD<T,NoInterlace> & field )
--- /dev/null
+#ifndef GAUSS_LOCALIZATION_HXX
+#define GAUSS_LOCALIZATION_HXX
+
+#include <vector>
+#include "MEDMEM_define.hxx"
+#include "MEDMEM_Exception.hxx"
+#include "MEDMEM_ArrayInterface.hxx"
+#include "MEDMEM_nArray.hxx"
+#include "MEDMEM_DriversDef.hxx"
+#include "MEDMEM_SetInterlacingType.hxx"
+
+using namespace std;
+using namespace MEDMEM;
+using namespace MED_EN;
+
+namespace MEDMEM {
+
+ class GAUSS_LOCALIZATION_ {
+ public:
+ virtual MED_EN::medModeSwitch getInterlacingType() const {return MED_EN::MED_UNDEFINED_INTERLACE;}
+ virtual ~GAUSS_LOCALIZATION_() {}; //Indispensable pour détruire le vrai objet pointé
+ };
+
+ template <class INTERLACING_TAG=FullInterlace> class GAUSS_LOCALIZATION;
+
+ template <class INTERLACING_TAG> ostream & operator<< (ostream &os,
+ const GAUSS_LOCALIZATION<INTERLACING_TAG> &loc);
+
+ template <class INTERLACING_TAG> class GAUSS_LOCALIZATION : public GAUSS_LOCALIZATION_{
+ public:
+ typedef typename MEDMEM_ArrayInterface<double,INTERLACING_TAG,NoGauss>::Array ArrayNoGauss;
+
+ protected:
+
+ string _locName;
+ MED_EN::medGeometryElement _typeGeo;
+ int _nGauss;
+ ArrayNoGauss _cooRef;
+ ArrayNoGauss _cooGauss;
+ vector<double> _wg;
+ MED_EN::medModeSwitch _interlacingType;
+
+ public:
+ friend ostream & operator<< <INTERLACING_TAG>(ostream &os,
+ const GAUSS_LOCALIZATION<INTERLACING_TAG> &loc);
+
+ GAUSS_LOCALIZATION() throw (MEDEXCEPTION);
+ GAUSS_LOCALIZATION(const string & locName,
+ const MED_EN::medGeometryElement typeGeo,
+ const int nGauss,
+ const ArrayNoGauss & cooRef,
+ const ArrayNoGauss & cooGauss,
+ const vector<double> & wg) throw (MEDEXCEPTION);
+
+ GAUSS_LOCALIZATION(const string & locName,
+ const MED_EN::medGeometryElement typeGeo,
+ const int nGauss,
+ const double * const cooRef,
+ const double * const cooGauss,
+ const double * const wg) throw (MEDEXCEPTION);
+
+ //GAUSS_LOCALIZATION(const GAUSS_LOCALIZATION & loc); constructeur de recopie par défaut correct
+ virtual ~GAUSS_LOCALIZATION() {};
+ GAUSS_LOCALIZATION & operator=(const GAUSS_LOCALIZATION & gaussLoc);
+ bool operator == (const GAUSS_LOCALIZATION &loc) const;
+
+ string getName() const {return _locName;}
+ MED_EN::medGeometryElement getType() const {return _typeGeo;}
+ int getNbGauss() const {return _nGauss;}
+ ArrayNoGauss getRefCoo () const {return _cooRef;} //Ces tableaux sont petits
+ ArrayNoGauss getGsCoo () const {return _cooGauss;} //Ces tableaux sont petits
+ vector <double> getWeight () const {return _wg;} //Ces tableaux sont petits
+ inline MED_EN::medModeSwitch getInterlacingType() const { return _interlacingType;}
+
+ };
+ template <class INTERLACING_TAG> GAUSS_LOCALIZATION<INTERLACING_TAG>::GAUSS_LOCALIZATION() throw (MEDEXCEPTION) : _typeGeo(MED_EN::MED_NONE), _nGauss(-1),
+ _interlacingType(_interlacingType( SET_INTERLACING_TYPE<INTERLACING_TAG>::_interlacingType)) {};
+ template <class INTERLACING_TAG> GAUSS_LOCALIZATION<INTERLACING_TAG>::GAUSS_LOCALIZATION(const string & locName,
+ const MED_EN::medGeometryElement typeGeo,
+ const int nGauss,
+ const ArrayNoGauss & cooRef,
+ const ArrayNoGauss & cooGauss,
+ const vector<double> & wg) throw (MEDEXCEPTION) :
+ _locName(locName),_typeGeo(typeGeo),_nGauss(nGauss),_cooRef(cooRef),_cooGauss(cooGauss),_wg(wg),
+ _interlacingType(SET_INTERLACING_TYPE<INTERLACING_TAG>::_interlacingType)
+ {
+ const char * LOC = "GAUSS_LOCALIZATION(locName,typeGeo, nGauss, const ArrayNoGauss & cooRef,..) : ";
+ BEGIN_OF(LOC);
+ if (_cooRef.getDim() != _cooGauss.getDim() )
+ throw MEDEXCEPTION( LOCALIZED( STRING(LOC) <<"cooRef and cooGaus must have the same number of components")) ;
+
+ if (_cooRef.getArraySize() != (_typeGeo%100)*(_typeGeo/100) )
+ throw MEDEXCEPTION( LOCALIZED( STRING(LOC) <<"cooRef size is " << _cooRef.getArraySize()
+ << " and should be (_typeGeo%100)*(_typeGeo/100) "
+ << (_typeGeo%100)*(_typeGeo/100))) ;
+
+ if (_cooGauss.getArraySize() != _nGauss*(_typeGeo/100) )
+ throw MEDEXCEPTION( LOCALIZED( STRING(LOC) <<"cooGauss must be of size nGauss*(_typeGeo/100) "
+ << _nGauss*(_typeGeo/100) ));
+ if (_wg.size() != _nGauss )
+ throw MEDEXCEPTION( LOCALIZED( STRING(LOC) <<"wg must be of size nGauss "
+ << _nGauss ));
+
+ END_OF(LOC);
+ };
+
+ template <class INTERLACING_TAG> GAUSS_LOCALIZATION<INTERLACING_TAG>::GAUSS_LOCALIZATION(const string & locName,
+ const MED_EN::medGeometryElement typeGeo,
+ const int nGauss,
+ const double * const cooRef,
+ const double * const cooGauss,
+ const double * const wg) throw (MEDEXCEPTION) :
+ _locName(locName),_typeGeo(typeGeo),_nGauss(nGauss),
+ _cooRef(ArrayNoGauss(const_cast<double *>(cooRef),typeGeo/100,typeGeo%100)),
+ _cooGauss(ArrayNoGauss(const_cast<double *>(cooGauss),typeGeo/100,_nGauss)),
+ _wg(vector<double>(wg,wg+nGauss)),
+ _interlacingType(SET_INTERLACING_TYPE<INTERLACING_TAG>::_interlacingType)
+ {
+ const char * LOC = "GAUSS_LOCALIZATION(locName,typeGeo, nGauss, const double * cooRef,..) :";
+ BEGIN_OF(LOC);
+ if (_cooRef.getDim() != _cooGauss.getDim() )
+ throw MEDEXCEPTION( LOCALIZED( STRING(LOC) <<"cooRef and cooGaus must have the same number of components")) ;
+
+ if (_cooRef.getArraySize() != (_typeGeo%100)*(_typeGeo/100) )
+ throw MEDEXCEPTION( LOCALIZED( STRING(LOC) <<"cooRef must be of size (_typeGeo%100)*(_typeGeo/100) "
+ << (_typeGeo%100)*(_typeGeo/100))) ;
+
+ if (_cooGauss.getArraySize() != _nGauss*(_typeGeo/100) )
+ throw MEDEXCEPTION( LOCALIZED( STRING(LOC) <<"cooGauss must be of size nGauss*(_typeGeo/100) "
+ << _nGauss*(_typeGeo/100) ));
+ if (_wg.size() != _nGauss )
+ throw MEDEXCEPTION( LOCALIZED( STRING(LOC) <<"wg must be of size nGauss "
+ << _nGauss ));
+ END_OF(LOC);
+ };
+
+ template <class INTERLACING_TAG> GAUSS_LOCALIZATION<INTERLACING_TAG> &
+ GAUSS_LOCALIZATION<INTERLACING_TAG>::operator=(const GAUSS_LOCALIZATION & gaussLoc)
+ {
+ if ( this == &gaussLoc) return *this;
+
+ _locName = gaussLoc._locName;
+ _typeGeo = gaussLoc._typeGeo;
+ _nGauss = gaussLoc._nGauss;
+ _cooRef = ArrayNoGauss(gaussLoc._cooRef); //utilisation de la copie superficielle par défaut n'est pas une bonne idée
+ _cooGauss = ArrayNoGauss(gaussLoc._cooGauss); //dans l'opérateur = de MEDnArray
+ _wg = gaussLoc._wg;
+
+ return *this;
+ }
+
+ template <class INTERLACING_TAG> bool
+ GAUSS_LOCALIZATION<INTERLACING_TAG>::operator == (const GAUSS_LOCALIZATION & gaussLoc) const {
+ return (
+ _locName == gaussLoc._locName &&
+ _typeGeo == gaussLoc._typeGeo &&
+ _nGauss == gaussLoc._nGauss &&
+ _cooRef == gaussLoc._cooRef && //utilisation de la copie superficielle par défaut n'est pas une bonne idée
+ _cooGauss == gaussLoc._cooGauss && //dans l'opérateur = de MEDnArray
+ _wg == gaussLoc._wg
+ );
+ }
+
+
+ template <class INTERLACING_TAG> ostream & MEDMEM::operator<<(ostream &os,
+ const GAUSS_LOCALIZATION<INTERLACING_TAG> &loc) {
+ os << "Localization Name : " << loc._locName << endl;
+ os << "Geometric Type : " << MED_EN::geoNames[loc._typeGeo]<< endl;
+ os << "Number Of GaussPoints : " << loc._nGauss << endl;
+ os << "Ref. Element Coords : " << endl << loc._cooRef << endl;
+ os << "Gauss points Coords : " << endl << loc._cooGauss << endl;
+ os << "Gauss points weigth : " << endl ;
+ for(int i=0; i<loc._wg.size();++i)
+ os << "_wg[" << i << "] = " << loc._wg[i] << endl;
+ return os;
+ }
+
+} //END NAMESPACE
+
+#endif
_numberOfGeometricType = myFamily->getNumberOfTypes() ;
_geometricType.set(_numberOfGeometricType);
- _numberOfGaussPoint.set(_numberOfGeometricType) ;
_numberOfElements.set(_numberOfGeometricType) ;
const medGeometryElement * geometricType = myFamily->getTypes() ;
//int * geometricTypeNumber = myFamily->getGeometricTypeNumber() ;
- const int * numberOfGaussPoint = myFamily->getNumberOfGaussPoint() ;
SCRUTE(_numberOfGeometricType);
for (int i=0 ; i<_numberOfGeometricType; i++) {
_geometricType[i]= geometricType[i] ;
// _geometricTypeNumber[i] = geometricTypeNumber[i] ;
- _numberOfGaussPoint[i] = numberOfGaussPoint[i] ;
_numberOfElements[i]=myFamily->getNumberOfElements(geometricType[i]);
MESSAGE(LOC << " Type : " << _geometricType[i] << " number of element(s) " << _numberOfElements[i]);
}
// _numberOfGeometricType = myFamily->getNumberOfTypes() ;
// _geometricType = new medGeometryElement[_numberOfGeometricType];
// //_geometricTypeNumber = new int[_numberOfGeometricType] ;
-// _numberOfGaussPoint = new int[_numberOfGeometricType] ;
+// _numberOfGaussPoints = new int[_numberOfGeometricType] ;
// _numberOfElements = new int[_numberOfGeometricType] ;
// medGeometryElement * geometricType = myFamily->getTypes() ;
// //int * geometricTypeNumber = myFamily->getGeometricTypeNumber() ;
-// int * numberOfGaussPoint = myFamily->getNumberOfGaussPoint() ;
+// int * numberOfGaussPoints = myFamily->getNumberOfGaussPoints() ;
// for (int i=0 ; i<_numberOfGeometricType; i++) {
// _geometricType[i]= geometricType[i] ;
// // _geometricTypeNumber[i] = geometricTypeNumber[i] ;
-// _numberOfGaussPoint[i] = numberOfGaussPoint[i] ;
+// _numberOfGaussPoints[i] = numberOfGaussPoints[i] ;
// _numberOfElements[i]=myFamily->getNumberOfElements(geometricType[i]);
// }
// _isOnAllElts = false ;
--- /dev/null
+#include "MEDMEM_MEDMEMchampLire.hxx"
+/*
+ * En attendant une correction de la gestion du mode d'accès au fichier dans MEDfichier
+ * on intègre la correction ici.
+ */
+
+namespace med_2_2 {
+ extern "C" {
+
+# define ICI { \
+ fflush(stdout); \
+ fprintf(stderr, "%s [%d] : " , __FILE__ , __LINE__ ) ; \
+ fflush(stderr) ; \
+ }
+
+# define ISCRUTE(entier) { \
+ ICI ; \
+ fprintf(stderr,"%s = %d\n",#entier,entier) ; \
+ fflush(stderr) ; \
+ }
+
+# define SSCRUTE(chaine) { \
+ ICI ; \
+ fprintf(stderr,"%s = \"%s\"\n",#chaine,chaine) ; \
+ fflush(stderr) ; \
+ }
+# define MESSAGE(chaine) { \
+ ICI ; \
+ fprintf(stderr,"%s\n",chaine) ; \
+ fflush(stderr) ; \
+ }
+
+ extern void _MEDmodeErreurVerrouiller(void);
+
+ /*************************************************************************
+ * COPYRIGHT (C) 1999 - 2003 EDF R&D
+ * THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+ * IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE
+ * AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION;
+ * EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+ *
+ * THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+ * WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+ * LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+ *
+ * YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+ * ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+ * INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+ *
+ *************************************************************************/
+
+#include <med.h>
+#include <med_outils.h>
+
+#include <string.h>
+#include <stdlib.h>
+
+ /*
+ * - Nom de la fonction : MEDchampLire
+ * - Description : Lecture d'un Champ Résultat
+ * - Parametres :
+ * - fid (IN) : ID du fichier HDF courant
+ * - maa (IN) : le nom du maillage sur lequel s'applique le champ
+ * - cha (IN) : le nom du champ
+ * - val (OUT) : valeurs du champ à lire
+ * - interlace(IN) : entrelacement voulu en mémoire {MED_FULL_INTERLACE,MED_NO_INTERLACE}
+ * - numco (IN) : n° de la composante à lire (MED_ALL si toutes)
+ * - profil (OUT) : nom du profil utilisé (MED_NOPFL si inutilisé)
+ * - pflmod (IN) : Indique comment lire les informations en mémoire { MED_COMPACT, MED_GLOBALE }.
+ * - type_ent (IN) : entité concerné par le champ {MED_NOEUD,MED_ARETE,MED_FACE,MED_MAILLE}
+ * - type_geo (IN) : type géométrique de l'entité concerné {MED_POINT,MED_SEG2 ......}
+ * - numdt (IN) : n° du pas de temps (MED_NOPDT si aucun)
+ * - numo (IN) : n° d'ordre utilisé MED_NONOR si inutile
+ * - Resultat : 0 en cas de succes, -1 sinon
+ */
+
+ /* REM : La taille de val allouée par l'utilisateur doit prendre en compte le nbre de points de gauss et le nbre de composantes*/
+
+ med_err
+ MEDMEMchampLire(med_idt fid,char *maa, char *cha, unsigned char *val,med_mode_switch interlace,med_int numco,
+ char * locname, char *profil, med_mode_profil pflmod,
+ med_entite_maillage type_ent, med_geometrie_element type_geo,
+ med_int numdt, med_int numo)
+
+ {
+ med_err ret=-1;
+ med_idt gid=0, datagroup1=0, datagroup2=0,datagroup3=0;
+ med_int ncomp=0, chtype=0, ngauss=0, i=0, pfluse=0;
+ char nomdatagroup1[2*MED_TAILLE_NOM_ENTITE+2]="",nomdatagroup2[2*MED_MAX_PARA+1]="";
+ char tmp1[MED_TAILLE_NOM_ENTITE+1]="", pfltmp[MED_TAILLE_NOM+1]="";
+ char chemin[MED_TAILLE_CHA+MED_TAILLE_NOM+1]="";
+ med_size psize=0;
+ med_int *pfltabtmp=0;
+ med_ssize *pfltab=0;
+
+ /*
+ * On inhibe le gestionnaire d'erreur HDF 5
+ */
+ _MEDmodeErreurVerrouiller();
+
+ /*
+ * Si le Data Group cha n'existe pas => erreur
+ */
+ strcpy(chemin,MED_CHA);
+ strcat(chemin,cha);
+ if ((gid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
+ goto ERROR;
+
+ /* Lecture du nbre de composantes du champ */
+
+ if (_MEDattrEntierLire(gid,MED_NOM_NCO,&ncomp) < 0)
+ goto ERROR;
+
+ /*
+ * Si le Data Group de niveau 1 <type_ent>[.<type_geo>] n'existe pas => erreur
+ */
+ if (_MEDnomEntite(nomdatagroup1,type_ent) < 0)
+ goto ERROR;
+ if ((type_ent != MED_NOEUD))
+ {
+ if (_MEDnomGeometrie(tmp1,type_geo) < 0)
+ goto ERROR;
+ strcat(nomdatagroup1,".");
+ strcat(nomdatagroup1,tmp1);
+ }
+ datagroup1 = 0;
+ if ( (datagroup1 = _MEDdatagroupOuvrir(gid,nomdatagroup1)) < 0 )
+ goto ERROR;
+
+ /*
+ * Si le Data Group de niveau 2 <numdt>.<numoo> n'existe pas => erreur
+ */
+ sprintf(nomdatagroup2,"%*li%*li",MED_MAX_PARA,(long ) numdt,MED_MAX_PARA,(long ) numo);
+
+ datagroup2 = 0;
+ if ( (datagroup2 = _MEDdatagroupOuvrir(datagroup1,nomdatagroup2)) < 0)
+ goto ERROR;
+
+ /*
+ * Ouvre le datagroup de niveau 3 <maa>
+ */
+
+ if ( ! strcmp(maa,MED_NOREF) )
+ if (_MEDattrStringLire(datagroup2,MED_NOM_MAI,MED_TAILLE_NOM,maa) < 0)
+ goto ERROR;
+
+ datagroup3 = 0;
+ if ( (datagroup3 = _MEDdatagroupOuvrir(datagroup2,maa)) < 0 )
+ goto ERROR;
+
+ /* Gestion des profils*/
+
+ /*
+ * Lire le profil
+ */
+
+ if (_MEDattrStringLire(datagroup3,MED_NOM_PFL,MED_TAILLE_NOM,pfltmp) < 0)
+ goto ERROR;
+
+ if ( pfluse = (strcmp(pfltmp,MED_NOPFLi) && strcmp(pfltmp,"")) ) /* le test MED_NOPFLi pour des raisons de compatibilité */
+ {
+ strcpy(profil,pfltmp);
+ if ( (i = MEDnValProfil(fid,profil)) < 0 )
+ goto ERROR;
+ else
+ psize = i;
+
+ pfltabtmp = (med_int *) malloc (sizeof(med_int)*psize);
+ pfltab = (med_ssize *) malloc (sizeof(med_ssize)*psize);
+ if (MEDprofilLire(fid,pfltabtmp,profil) < 0)
+ goto ERROR;
+ for (i=0;i<psize;i++)
+ pfltab[i] = (med_ssize) pfltabtmp[i];
+
+ }
+ else {
+ psize = MED_NOPF;
+ strcpy(profil,MED_NOPFL);
+ }
+
+
+ /* Lire le nbre des points de GAUSS*/
+ if (_MEDattrEntierLire(datagroup3,MED_NOM_NGA,&ngauss) < 0) {
+ MESSAGE("Erreur à la lecture de l'attribut MED_NOM_NGA : ");
+ ISCRUTE(ngauss);goto ERROR;
+ };
+
+ /* Lire l'identificateur de localisation des points de GAUSS*/
+ if ( _MEDattrStringLire(datagroup3,MED_NOM_GAU,MED_TAILLE_NOM,locname) < 0) {
+ MESSAGE("Erreur à la lecture de l'attribut MED_NOM_GAU : ");
+ SSCRUTE(locname); goto ERROR;
+ }
+
+ /*
+ * Lecture du champ
+ */
+
+ if (_MEDattrEntierLire(gid,MED_NOM_TYP,&chtype) < 0)
+ goto ERROR;
+
+ switch(chtype)
+ {
+ case MED_FLOAT64 :
+ if ( _MEDdatasetNumLire(datagroup3,MED_NOM_CO,MED_FLOAT64,
+ interlace,ncomp,numco,
+ psize,pflmod,pfltab,ngauss,val)< 0)
+ goto ERROR;
+ break;
+
+ case MED_INT32 :
+#if defined(F77INT64)
+ if ( _MEDdatasetNumLire(datagroup3,MED_NOM_CO,MED_INT64,
+ interlace,ncomp,numco,
+ psize,pflmod,pfltab,ngauss,val)< 0)
+ goto ERROR;
+#else
+ if ( _MEDdatasetNumLire(datagroup3,MED_NOM_CO,MED_INT32,
+ interlace,ncomp,numco,
+ psize,pflmod,pfltab,ngauss,val)< 0)
+ goto ERROR;
+#endif
+ break;
+
+ case MED_INT64 :
+#if defined(F77INT64)
+ if ( _MEDdatasetNumLire(datagroup3,MED_NOM_CO,MED_INT64,
+ interlace,ncomp,numco,
+ psize,pflmod,pfltab,ngauss,val)< 0)
+ goto ERROR;
+#else
+ goto ERROR;
+#endif
+ break;
+
+ default :
+ goto ERROR;
+ }
+
+ /*
+ * On ferme tout
+ */
+
+ ret = 0;
+
+ ERROR:
+
+ if ( pfluse ) { free(pfltab); free(pfltabtmp);}
+
+ if (datagroup3>0) if (_MEDdatagroupFermer(datagroup3) < 0) {
+ MESSAGE("Impossible de fermer le datagroup : ");
+ ISCRUTE(datagroup3); ret = -1;
+ }
+
+ if (datagroup2>0) if (_MEDdatagroupFermer(datagroup2) < 0) {
+ MESSAGE("Impossible de fermer le datagroup : ");
+ ISCRUTE(datagroup2); ret = -1;
+ }
+
+ if (datagroup1>0) if (_MEDdatagroupFermer(datagroup1) < 0) {
+ MESSAGE("Impossible de fermer le datagroup : ");
+ ISCRUTE(datagroup1); ret = -1;
+ }
+
+ if (gid>0) if (_MEDdatagroupFermer(gid) < 0) {
+ MESSAGE("Impossible de fermer le datagroup : ");
+ ISCRUTE(gid); ret = -1;
+ }
+
+ return ret;
+ }
+
+
+#undef MESSAGE
+#undef SSCRUTE
+#undef ISCRUTE
+
+ }
+}
+
+
--- /dev/null
+#ifndef MEDMEM_MEDMEM_CHAMPLIRE_HXX
+#define MEDMEM_MEDMEM_CHAMPLIRE_HXX
+/*
+ * En attendant une correction de la gestion du mode d'accès au fichier dans MEDfichier
+ * on intègre la correction ici.
+ */
+namespace med_2_2 {
+ extern "C" {
+
+# define __UTILITES_H__
+#include <med_outils.h>
+# undef __UTILITES_H__
+
+#include <string.h>
+#include <stdlib.h>
+
+med_err
+MEDMEMchampLire(med_idt fid,char *maa, char *cha, unsigned char *val,med_mode_switch interlace,med_int numco,
+ char * locname, char *profil, med_mode_profil pflmod,
+ med_entite_maillage type_ent, med_geometrie_element type_geo,
+ med_int numdt, med_int numo);
+
+
+ }
+}
+
+#endif
--- /dev/null
+#include "MEDMEM_MEDMEMgaussEcr.hxx"
+/*
+ * En attendant une correction de la gestion du mode d'accès au fichier dans MEDfichier
+ * on intègre la correction ici.
+ */
+
+namespace med_2_2 {
+ extern "C" {
+# define ICI {\
+ fflush(stdout);\
+ fprintf(stderr, "%s [%d] : " , __FILE__ , __LINE__ ) ;\
+ fflush(stderr) ;\
+ }
+
+# define ISCRUTE(entier) {\
+ ICI ;\
+ fprintf(stderr,"%s = %d\n",#entier,entier) ;\
+ fflush(stderr) ;\
+ }
+
+# define SSCRUTE(chaine) {\
+ ICI ;\
+ fprintf(stderr,"%s = \"%s\"\n",#chaine,chaine) ;\
+ fflush(stderr) ;\
+ }
+# define MESSAGE(chaine) {\
+ ICI ;\
+ fprintf(stderr,"%s\n",chaine) ;\
+ fflush(stderr) ;\
+ }
+
+ extern void _MEDmodeErreurVerrouiller(void);
+
+ /*************************************************************************
+ * COPYRIGHT (C) 1999 - 2003 EDF R&D
+ * THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+ * IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE
+ * AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION;
+ * EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+ *
+ * THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+ * WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+ * LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+ *
+ * YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+ * ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+ * INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+ *
+ *************************************************************************/
+
+ /*
+ * - Nom de la fonction : MEDgaussEcr
+ * - Description : Itérateur renvoyant (n°pdt,n°or), le nbre de point de GAUSS pour le type d'élément,
+ * et le maillage par défaut avec son eventuel lien à un autre fichier.
+ * - Parametres :
+ * - fid (IN) : ID du fichier HDF courant
+ * - type_geo (IN) : Le type géométrique de l'entité concerné {MED_POINT,MED_SEG2 ......}
+ * - refcoo (IN) : Les coordonnées des noeuds de l'élément de référence (tableau de taille(typegeo%100)*(typegeo/100) )
+ * - mode_coo (IN) : Choix du type d'entrelacement utilisé en mémoire pour refcoo et gscoo
+ * { MED_FULL_INTERLACE(x1,y1,z1,x2,...)) , MED_NO_INTERLACE(x1,x2,y1,y2,z1,z2) }
+ * - ngauss (IN) : Nombre de points de Gauss pour l'élément de référence considéré
+ * - gscoo (IN) : Les coordonnées des points de Gauss pour l'élément de référence (tableau de taille ngauss*type_geo/100)
+ * - wg (IN) : Poids à appliquer aux points d'intégration (tableau de taille ngauss)
+ * - locname (IN) : Nom à associer à la localisation (MED_TAILLe_NOM)
+
+ REM :
+ <locname> est à passer en paramètre de MEDchampEcrire.
+ */
+
+ med_err
+ MEDMEMgaussEcr(med_idt fid, med_geometrie_element type_geo, med_float *refcoo, med_mode_switch mode_coo,
+ med_int ngauss, med_float *gscoo, med_float * wg, char * locname )
+ {
+ med_idt gid=0, chid=0;
+ med_size dimd[1];
+ med_err ret = -1;
+ med_int typegeo = -1;
+ char chemin[MED_TAILLE_GAUSS+1]="";
+
+ /*
+ * On inhibe le gestionnaire d'erreur HDF 5
+ */
+ _MEDmodeErreurVerrouiller();
+
+ /*
+ * Si le groupe "GAUSS" n'existe pas, on le cree
+ */
+ strncpy(chemin,MED_GAUSS,MED_TAILLE_GAUSS-1);
+ chemin[MED_TAILLE_GAUSS-1] = '\0';
+ if ((gid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
+ if ((gid = _MEDdatagroupCreer(fid,chemin)) < 0) {
+ MESSAGE("Impossible de creer le groupe MED_GAUSS : ");
+ SSCRUTE(chemin); goto ERROR;
+ }
+
+ /*
+ * Si le groupe <locname> n'existe pas, on le cree
+ * Sinon => erreur
+ */
+ if ((chid = _MEDdatagroupOuvrir(gid,locname)) >= 0) {
+ if ( MED_MODE_ACCES != MED_LECTURE_ECRITURE ) {
+ MESSAGE("Le nom de localisation existe déjà : ");
+ SSCRUTE(locname); goto ERROR;
+ }
+ } else
+ if ((chid = _MEDdatagroupCreer(gid,locname)) < 0)
+ goto ERROR;
+
+ /*
+ * On stocke <ngauss> sous forme d'attribut
+ */
+ if (_MEDattrEntierEcrire(chid,MED_NOM_NBR,&ngauss) < 0) {
+ MESSAGE("Erreur à l'écriture de l'attribut MED_NOM_NBR : ");
+ ISCRUTE(ngauss);goto ERROR;
+ };
+
+ /*
+ * On stocke <type_geo> sous forme d'attribut
+ */
+ typegeo = (med_int) type_geo;
+ /* sizeof(enum) tjrs = sizeof(int) en C, or
+ sur machines 64 bits par défaut med_int==long,
+ du coup sur machines 64 bits _MEDattrEntierEcrire utilise
+ le type hdf NATIVE_LONG, ce qui pose un problème qd on passe
+ un enum.
+ */
+ if (_MEDattrEntierEcrire(chid,MED_NOM_GEO,&typegeo) < 0) {
+ MESSAGE("Erreur à l'écriture de l'attribut MED_NOM_GEO : ");
+ ISCRUTE(type_geo);goto ERROR;
+ };
+
+
+ /*
+ * On stocke les coordonnées de référence dans un dataset
+ */
+
+ dimd[0] = (type_geo%100)*(type_geo/100);
+ if ( _MEDdatasetNumEcrire(chid,MED_NOM_COO,MED_FLOAT64,mode_coo,(type_geo/100),MED_ALL,MED_NOPF,MED_NO_PFLMOD,0,MED_NOPG,dimd,
+ (unsigned char*) refcoo) < 0 ) {
+ MESSAGE("Impossible d'ecrire le dataset : ");SSCRUTE(MED_NOM_COO);
+ ISCRUTE(dimd); goto ERROR;
+ }
+
+ /*
+ * On stocke les points d'intégration dans un dataset
+ */
+
+ dimd[0] = ngauss*(type_geo/100);
+ if ( _MEDdatasetNumEcrire(chid,MED_NOM_GAU,MED_FLOAT64,mode_coo,(type_geo/100),MED_ALL,MED_NOPF,MED_NO_PFLMOD,0,MED_NOPG,dimd,
+ (unsigned char*) gscoo) < 0 ) {
+ MESSAGE("Impossible d'ecrire le dataset : ");SSCRUTE(MED_NOM_GAU);
+ ISCRUTE(dimd); goto ERROR;
+ }
+
+ /*
+ * On stocke les poids dans un dataset
+ */
+
+ dimd[0] = ngauss;
+ if ( _MEDdatasetNumEcrire(chid,MED_NOM_VAL,MED_FLOAT64,mode_coo,1,MED_ALL,MED_NOPF,MED_NO_PFLMOD,0,MED_NOPG,dimd,
+ (unsigned char*) wg) < 0 ) {
+ MESSAGE("Impossible d'ecrire le dataset : ");SSCRUTE(MED_NOM_VAL);
+ ISCRUTE(dimd); goto ERROR;
+ }
+
+
+ ret = 0;
+
+ ERROR:
+
+ /*
+ * On ferme tout
+ */
+
+ if (chid>0) if (_MEDdatagroupFermer(chid) < 0) {
+ MESSAGE("Impossible de fermer le datagroup : ");
+ ISCRUTE(chid); ret = -1;
+ }
+
+ if (gid>0) if (_MEDdatagroupFermer(gid) < 0) {
+ MESSAGE("Impossible de fermer le datagroup : ");
+ ISCRUTE(gid); ret = -1;
+ }
+
+ return ret;
+ }
+
+#undef MESSAGE
+#undef SSCRUTE
+#undef ISCRUTE
+
+ }
+}
--- /dev/null
+#ifndef MEDMEM_MEDMEM_GAUSSECR_HXX
+#define MEDMEM_MEDMEM_GAUSSECR_HXX
+/*
+ * En attendant une correction de la gestion du mode d'accès au fichier dans MEDfichier
+ * on intègre la correction ici.
+ */
+namespace med_2_2 {
+ extern "C" {
+
+# define __UTILITES_H__
+#include <med_outils.h>
+# undef __UTILITES_H__
+
+#include <string.h>
+#include <stdlib.h>
+
+med_err
+MEDMEMgaussEcr(med_idt fid, med_geometrie_element type_geo, med_float *refcoo, med_mode_switch mode_coo,
+ med_int ngauss, med_float *gscoo, med_float * wg, char * locname );
+
+ }
+}
+
+#endif
--- /dev/null
+#include "MEDMEM_MEDMEMprofilEcr.hxx"
+/*
+ * En attendant une correction de la gestion du mode d'accès au fichier dans MEDfichier
+ * on intègre la correction ici.
+ */
+
+namespace med_2_2 {
+ extern "C" {
+
+# define ICI { \
+ fflush(stdout); \
+ fprintf(stderr, "%s [%d] : " , __FILE__ , __LINE__ ) ; \
+ fflush(stderr) ; \
+ }
+
+# define ISCRUTE(entier) { \
+ ICI ; \
+ fprintf(stderr,"%s = %d\n",#entier,entier) ; \
+ fflush(stderr) ; \
+ }
+
+# define SSCRUTE(chaine) { \
+ ICI ; \
+ fprintf(stderr,"%s = \"%s\"\n",#chaine,chaine) ; \
+ fflush(stderr) ; \
+ }
+# define MESSAGE(chaine) { \
+ ICI ; \
+ fprintf(stderr,"%s\n",chaine) ; \
+ fflush(stderr) ; \
+ }
+
+ extern void _MEDmodeErreurVerrouiller(void);
+
+ /*************************************************************************
+ * COPYRIGHT (C) 1999 - 2003 EDF R&D
+ * THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+ * IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE
+ * AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION;
+ * EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
+ *
+ * THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+ * WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+ * LESSER GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+ *
+ * YOU SHOULD HAVE RECEIVED A COPY OF THE GNU LESSER GENERAL PUBLIC LICENSE
+ * ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
+ * INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
+ *
+ *************************************************************************/
+
+#include <med.h>
+#include <med_outils.h>
+
+#include <string.h>
+#include <stdlib.h>
+
+ med_err
+ MEDMEMprofilEcr(med_idt fid,med_int *pflval,med_int n,char *profilname)
+ {
+ med_idt gid, chid;
+ med_size dimd[1];
+ med_err ret;
+ char chemin[MED_TAILLE_PROFILS+1];
+
+ /*
+ * On inhibe le gestionnaire d'erreur HDF 5
+ */
+ _MEDmodeErreurVerrouiller();
+
+ /*
+ * Si le groupe "PROFILS" n'existe pas, on le cree
+ */
+ strncpy(chemin,MED_PROFILS,MED_TAILLE_PROFILS-1);
+ chemin[MED_TAILLE_PROFILS-1] = '\0';
+ if ((gid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
+ if ((gid = _MEDdatagroupCreer(fid,chemin)) < 0) {
+ MESSAGE("Impossible de creer le groupe MED_PROFILS : ");
+ SSCRUTE(chemin); goto ERROR;
+ }
+
+ /*
+ * Si le groupe "profilname" n'existe pas, on le cree
+ * Sinon => erreur
+ */
+ if ((chid = _MEDdatagroupOuvrir(gid,profilname)) >= 0) {
+ if ( MED_MODE_ACCES != MED_LECTURE_ECRITURE ) {
+ MESSAGE("Le profil existe déjà : ");
+ SSCRUTE(profilname); goto ERROR;
+ }
+ } else
+ if ((chid = _MEDdatagroupCreer(gid,profilname)) < 0)
+ goto ERROR;
+
+ /*
+ * On stocke "n" sous forme d'attribut
+ */
+ if ((ret = _MEDattrEntierEcrire(chid,MED_NOM_NBR,&n)) < 0) {
+ MESSAGE("Erreur à l'écriture de l'attribut MED_NOM_NBR : ");
+ ISCRUTE(n); goto ERROR;
+ };
+
+ /*
+ * On stocke le profil dans un dataset
+ */
+ dimd[0] = n;
+#if defined(F77INT64)
+ ret = _MEDdatasetNumEcrire(chid,MED_NOM_PFL,MED_INT64,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,MED_NO_PFLMOD,0,MED_NOPG,dimd,
+ (unsigned char*) pflval);
+#else
+ ret = _MEDdatasetNumEcrire(chid,MED_NOM_PFL,MED_INT32,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,MED_NO_PFLMOD,0,MED_NOPG,dimd,
+ (unsigned char*) pflval);
+#endif
+ if (ret < 0 ) {
+ MESSAGE("Impossible d'ecrire le dataset pflval de taille : ");
+ ISCRUTE(n); goto ERROR;
+ }
+
+ ret = 0;
+ ERROR:
+ /*
+ * On ferme tout
+ */
+ if (chid>0) if (_MEDdatagroupFermer(chid) < 0) {
+ MESSAGE("Impossible de fermer le datagroup : ");
+ ISCRUTE(chid); ret = -1;
+ }
+
+ if (gid>0) if (_MEDdatagroupFermer(gid) < 0) {
+ MESSAGE("Impossible de fermer le datagroup : ");
+ ISCRUTE(gid); ret = -1;
+ }
+
+ return ret;
+ }
+
+#undef MESSAGE
+#undef SSCRUTE
+#undef ISCRUTE
+
+ }
+}
+
+
+
+
--- /dev/null
+#ifndef MEDMEM_MEDMEM_PROFILECR_HXX
+#define MEDMEM_MEDMEM_PROFILECR_HXX
+/*
+ * En attendant une correction de la gestion du mode d'accès au fichier dans MEDfichier
+ * on intègre la correction ici.
+ */
+namespace med_2_2 {
+ extern "C" {
+
+# define __UTILITES_H__
+#include <med_outils.h>
+# undef __UTILITES_H__
+
+#include <string.h>
+#include <stdlib.h>
+
+ med_err
+ MEDMEMprofilEcr(med_idt fid,med_int *pflval,med_int n,char *profilname);
+
+ }
+}
+
+#endif
{
protected:
// Developement plus propre :
- // - Il faudrait soit utiliser le type FIELD_ et ajouter à cette classe
- // les accesseurs de FIELD<> utilisés dans les drivers
- // - Ou bien avoir des drivers à deux paramètres template (le top)
+ // - Il faudrait soit utiliser le type FIELD_ et ajouter à cette classe
+ // les accesseurs de FIELD<> utilisées dans les drivers
+ // - Ou bien avoir des drivers à deux paramètres template (le top)
// - Remarquez l'affreux cast dans le second constructeur :
// _ptrField( (FIELD<T> *) ptrField )
// Cela cast toujours le ptrField en FullInterlace
public :
- // all MED cell type ?? Classe de Définition ??
- // static const medGeometryElement all_cell_type[MED_NBR_GEOMETRIE_MAILLE];
-
- // static const char * const all_cell_type_tab [MED_NBR_GEOMETRIE_MAILLE];
-
/*!
Constructor.
*/
MED_EN::med_mode_acces accessMode)
: GENDRIVER(fileName,accessMode),
_ptrField((FIELD<T> *) ptrField),
- _fieldName(fileName),_fieldNum(MED_INVALID)
+ _fieldName(""),_fieldNum(MED_INVALID)
{
}
//med_2_1::med_geometrie_element..
MED_EN::medGeometryElement geometricType[MED_NBR_GEOMETRIE_MAILLE];
int numberOfElementsOfType[MED_NBR_GEOMETRIE_MAILLE];
- int numberOfGaussPoint[MED_NBR_GEOMETRIE_MAILLE];
+ int numberOfGaussPoints[MED_NBR_GEOMETRIE_MAILLE];
med_2_1::med_int ngauss=0, numdt=-1, numo=-1, nbPdtIt=0; //nmaa=0
char dtunit[MED_TAILLE_PNOM21+1], maa[MED_TAILLE_NOM+1];
//totalNumberOfElements+=numberOfElements;
numberOfElementsOfType[numberOfGeometricType] = numberOfElements/ngauss;
- numberOfGaussPoint[numberOfGeometricType] = ngauss;
+ numberOfGaussPoints[numberOfGeometricType] = ngauss;
anyGauss = (anyGauss || (ngauss-1) );
geometricType[numberOfGeometricType]= *currentGeometry;
numberOfGeometricType++;
support.setGeometricType(geometricType); // Utile uniquement si setAll == false
support.setNumberOfElements(numberOfElementsOfType); //setNumberOfElements effectue une copie
support.setAll(true);
- if (anyGauss)
- support.setNumberOfGaussPoint(numberOfGaussPoint);
return alreadyFoundAnEntity;
} else
// MED_FIELD_DRIVER<T>::_ptrField->_orderNumber) ;
NumberOfValues[i] = mySupport->getNumberOfElements(Types[i])
- * mySupport->getNumberOfGaussPoint(Types[i]);
+ * MED_FIELD_DRIVER<T>::_ptrField->getNumberOfGaussPoints(Types[i]);
myValues[i] = new T[ NumberOfValues[i]*numberOfComponents ] ;
TotalNumberOfValues+=NumberOfValues[i] ;
const SUPPORT * mySupport = MED_FIELD_DRIVER<T>::_ptrField->getSupport() ;
if (! mySupport->isOnAllElements())
- throw MEDEXCEPTION( LOCALIZED (STRING(LOC)
+ throw MEDEXCEPTION( LOCALIZED (STRING(LOC)
<<": Field must be on all entity"
)
);
int NumberOfType = mySupport->getNumberOfTypes() ;
int Index = 1 ;
const MED_EN::medGeometryElement * Types = mySupport->getTypes() ;
- const int * NumberOfGaussPoint = mySupport->getNumberOfGaussPoint() ;
const T * value = NULL;
ArrayFull * myArray = NULL;
for (int i=0;i<NumberOfType;i++) {
int NumberOfElements = mySupport->getNumberOfElements(Types[i]) ;
-
+ int NumberOfGaussPoints = MED_FIELD_DRIVER<T>::_ptrField->getNumberOfGaussPoints(Types[i]) ;
+
// const T * value = MED_FIELD_DRIVER<T>::_ptrField->getValueI(MED_EN::MED_FULL_INTERLACE,Index) ;
value = myArray->getRow(Index) ;
MESSAGE("MED_FIELD_DRIVER<T>::_ptrField->getName() : "<<MED_FIELD_DRIVER<T>::_ptrField->getName());
MESSAGE("value : "<<value);
MESSAGE("NumberOfElements : "<<NumberOfElements);
- MESSAGE("NumberOfGaussPoint[i] : "<<NumberOfGaussPoint[i]);
+ MESSAGE("NumberOfGaussPoints : "<<NumberOfGaussPoints);
MESSAGE("mySupport->getEntity() : "<<mySupport->getEntity());
MESSAGE("Types[i] : "<<Types[i]);
MESSAGE("MED_FIELD_DRIVER<T>::_ptrField->getIterationNumber() : "<<MED_FIELD_DRIVER<T>::_ptrField->getIterationNumber());
(unsigned char*)temp,
med_2_1::MED_FULL_INTERLACE,
NumberOfElements,
- NumberOfGaussPoint[i],
+ NumberOfGaussPoints,
MED_ALL,
MED_NOPFL,
med_2_1::MED_REMP, // PROFIL NON GERE, mode de remplacement non géré
(unsigned char*)value,
med_2_1::MED_FULL_INTERLACE,
NumberOfElements,
- NumberOfGaussPoint[i],
+ NumberOfGaussPoints,
MED_ALL,
MED_NOPFL,
med_2_1::MED_REMP, // PROFIL NON GERE, mode de remplacement non géré
#define MED_FIELD_DRIVER22_HXX
#include <string>
+#include <algorithm>
-#include "MEDMEM_define.hxx"
+#include "MEDMEM_FieldConvert.hxx"
+#include "MEDMEM_ArrayInterface.hxx"
+#include "MEDMEM_ArrayConvert.hxx"
-#include "MEDMEM_DriversDef.hxx"
+#include "MEDMEM_define.hxx"
#include "MEDMEM_Utilities.hxx"
-#include "MEDMEM_MedFieldDriver.hxx"
#include "MEDMEM_STRING.hxx"
#include "MEDMEM_Exception.hxx"
-#include "MEDMEM_Unit.hxx"
-
-#include "MEDMEM_ArrayInterface.hxx"
-#include "MEDMEM_ArrayConvert.hxx"
+#include "MEDMEM_DriversDef.hxx"
+#include "MEDMEM_MedFieldDriver.hxx"
+#include "MEDMEM_Unit.hxx"
#include "MEDMEM_Support.hxx"
-#include "MEDMEM_Mesh.hxx"
+#include "MEDMEM_GaussLocalization.hxx"
+
+//includes temporaires (attente release med fichier 2.3.1)
+#include "MEDMEM_MEDMEMgaussEcr.hxx"
+#include "MEDMEM_MEDMEMprofilEcr.hxx"
+#include "MEDMEM_MEDMEMchampLire.hxx"
namespace MEDMEM {
template <class T> class MED_FIELD_DRIVER22 : public virtual MED_FIELD_DRIVER<T>
{
protected:
-
+
med_2_2::med_idt _medIdt;
-
- bool createFieldSupport(med_2_2::med_idt id,
- string & fieldName,
+
+ bool createFieldSupportPart1(med_2_2::med_idt id,
+ const string & fieldName,
med_2_2::med_int ndt,
med_2_2::med_int od,
SUPPORT & support,
- string & meshName) const throw (MEDEXCEPTION);
+ string & meshName,
+ vector<int> & numberOfElementsOfTypeC,
+ vector<int> & numberOfGaussPoint,
+ int & totalNumberOfElWg
+ ) const throw (MEDEXCEPTION);
- void getMeshGeometricType(med_2_2::med_idt id,
+ void getMeshGeometricTypeFromFile(med_2_2::med_idt id,
string & meshName,
MED_EN::medEntityMesh entite,
vector<MED_EN::medGeometryElement> & geoType,
- vector<int> &nbOfElOfType) const;
+ vector<int> &nbOfElOfType,
+ vector<int> &nbOfElOfTypeC) const throw(MEDEXCEPTION);
+
+ void getMeshGeometricTypeFromMESH( MESH * meshPtr,
+ MED_EN::medEntityMesh entity,
+ vector<MED_EN::medGeometryElement> & geoType,
+ vector<int> &nbOfElOfType,
+ vector<int> &nbOfElOfTypeC) const throw(MEDEXCEPTION);
public :
*/
template <class INTERLACING_TAG>
MED_FIELD_DRIVER22(const string & fileName,
- FIELD<T, INTERLACING_TAG> * ptrField,
+ FIELD<T, INTERLACING_TAG> * ptrField,
MED_EN::med_mode_acces accessMode)
: MED_FIELD_DRIVER<T>(fileName,ptrField,accessMode),_medIdt(MED_INVALID)
{
/*!
Destructor.
*/
- virtual ~MED_FIELD_DRIVER22() {
+ virtual ~MED_FIELD_DRIVER22() {
}
void open() throw (MEDEXCEPTION)
// we must set fieldname before open, because we must find field number in file (if it exist !!!)
if ( MED_FIELD_DRIVER<T>::_fileName == "" )
- throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
+ throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
<< "_fileName is |\"\"|, please set a correct fileName before calling open()"
)
);
MESSAGE(LOC<<"_fileName.c_str : "<< MED_FIELD_DRIVER<T>::_fileName.c_str()<<",mode : "<< MED_FIELD_DRIVER<T>::_accessMode);
MED_FIELD_DRIVER22<T>::_medIdt = med_2_2::MEDouvrir( (const_cast <char *> (MED_FIELD_DRIVER<T>::_fileName.c_str())),(med_2_2::med_mode_acces) MED_FIELD_DRIVER<T>::_accessMode);
MESSAGE(LOC<<"_medIdt : "<< MED_FIELD_DRIVER22<T>::_medIdt );
- if (MED_FIELD_DRIVER22<T>::_medIdt > 0)
+ if (MED_FIELD_DRIVER22<T>::_medIdt > 0)
MED_FIELD_DRIVER<T>::_status=MED_OPENED;
else {
MED_FIELD_DRIVER<T>::_status = MED_INVALID;
MED_FIELD_DRIVER22<T>::_medIdt = MED_INVALID;
- throw MED_EXCEPTION (LOCALIZED( STRING(LOC)
- << "Can't open |" << MED_FIELD_DRIVER<T>::_fileName
+ throw MED_EXCEPTION (LOCALIZED( STRING(LOC)
+ << "Can't open |" << MED_FIELD_DRIVER<T>::_fileName
<< "|, _medIdt : " << MED_FIELD_DRIVER22<T>::_medIdt
)
);
END_OF(LOC);
}
-
+
void close() {
BEGIN_OF("MED_FIELD_DRIVER22::close()");
med_2_2::med_int err = 0;
template <class T> class MED_FIELD_RDONLY_DRIVER22 : public virtual MED_FIELD_DRIVER22<T>, public virtual IMED_FIELD_RDONLY_DRIVER<T>
{
-
+
public :
-
+
/*!
Constructor.
*/
MED_FIELD_RDONLY_DRIVER22():MED_FIELD_DRIVER<T>() {};
-
+
/*!
Constructor.
*/
IMED_FIELD_RDONLY_DRIVER<T>(fileName,ptrField),
MED_FIELD_DRIVER22<T>(fileName,ptrField,MED_EN::MED_RDONLY),
MED_FIELD_DRIVER<T>(fileName,ptrField,MED_EN::MED_RDONLY)
- {
+ {
BEGIN_OF("MED_FIELD_RDONLY_DRIVER22::MED_FIELD_RDONLY_DRIVER22(const string & fileName, const FIELD<T,INTERLACING_TAG> * ptrField)");
END_OF("MED_FIELD_RDONLY_DRIVER22::MED_FIELD_RDONLY_DRIVER22(const string & fileName, const FIELD<T,INTERLACING_TAG> * ptrField)");
}
-
+
/*!
Copy constructor.
*/
MED_FIELD_DRIVER22<T>(fieldDriver),
MED_FIELD_DRIVER<T>(fieldDriver)
{}
-
+
/*!
Destructor.
*/
*/
template <class T> class MED_FIELD_WRONLY_DRIVER22 : public virtual MED_FIELD_DRIVER22<T>, public virtual IMED_FIELD_WRONLY_DRIVER<T> {
-
+
public :
-
+
/*!
Constructor.
*/
MED_FIELD_WRONLY_DRIVER22():MED_FIELD_DRIVER<T>() {}
-
+
/*!
Constructor.
*/
MED_FIELD_DRIVER22<T>(fieldDriver),
MED_FIELD_DRIVER<T>(fieldDriver)
{}
-
+
/*!
Destructor.
*/
*/
template <class T> class MED_FIELD_RDWR_DRIVER22 : public MED_FIELD_RDONLY_DRIVER22<T>, public MED_FIELD_WRONLY_DRIVER22<T>, public IMED_FIELD_RDWR_DRIVER<T> {
-
+
public :
-
+
/*!
Constructor.
*/
MED_FIELD_RDWR_DRIVER22():MED_FIELD_DRIVER22<T>() {}
-
+
/*!
Constructor.
*/
IMED_FIELD_WRONLY_DRIVER<T>(fieldDriver),
MED_FIELD_DRIVER<T>(fieldDriver)
{};
-
+
/*!
Destructor.
*/
/*--------------------- DRIVER PART -------------------------------*/
+
+/*!
+
+ Cette méthode crée le SUPPORT du champ <fieldName> pour le
+ <n°de pas de temps,n°d'itération>=<ndt,od>.
+
+ Le SUPPORT crée à pour nom <fieldName>Support et contient
+ la liste des types géométriques sur le premier type
+ d'entité trouvé (en MEDMEM on inderdit aux champs de reposer
+ sur plusieurs types d'entité).
+ Il contient également le nombre d'entités trouvées pour chaque
+ type géométrique.
+ Par défaut l'attribut onAll du SUPPORT est positionné à true car
+ cette routine ne lit rien de ce qui concerne les entités
+ du maillage associé.
+ La méthode renvoie true si elle réussit à créer le SUPPORT
+ demandé.
+ Le nom du maillage associé ( en MEDMEM on ne
+ supporte pas encore les maillages multiples ) est renvoyé dans <meshName>.
+ Deux tableaux directements exploitables par MEDMEMnArray sont renvoyés :
+ - numberOfElementsOfTypeC : nombres d'entités cumulés de chaque type géométrique
+ avec numberOfElementsOfTypeC[0]=1 et de taille nombre de types+1
+ - numberOfGaussPoint : nombre de points de Gauss par type géométrique
+ avec numberOfGaussPoint[0]=1 et de taille nombre de types+1
+*/
+
template <class T> bool
-MED_FIELD_DRIVER22<T>::createFieldSupport(med_2_2::med_idt id,
- string & fieldName,
- med_2_2::med_int ndt,
- med_2_2::med_int od,
- SUPPORT & support,
- string & meshName) const throw (MEDEXCEPTION)
+MED_FIELD_DRIVER22<T>::createFieldSupportPart1(med_2_2::med_idt id,
+ const string & fieldName,
+ med_2_2::med_int ndt,
+ med_2_2::med_int od,
+ SUPPORT & support,
+ string & meshName,
+ vector<int> & numberOfElementsOfTypeC,
+ vector<int> & numberOfGaussPoint,
+ int & totalNumberOfElWg
+ ) const throw (MEDEXCEPTION)
{
- //EF : Gérer le meshName pour le driver 2.2
- const char * LOC="MED_FIELD_DRIVER<T>::search_field(...)";
+ //EF : Gérer le meshName pour le driver 2.2
+ const char * LOC="MED_FIELD_DRIVER<T>::createFieldSupportPart1(...)";
map<int, list<MED_EN::medGeometryElement> > CellAndNodeEntities;
map<int, list<MED_EN::medGeometryElement> >::iterator currentEntity;
CellAndNodeEntities[MED_EN::MED_NODE] = MED_EN::meshEntities[MED_EN::MED_NODE];
list< MED_EN::medGeometryElement >::const_iterator currentGeometry;
- //med_2_2::med_entite_maillage
MED_EN::medEntityMesh entity;
- bool alreadyFoundAnEntity=false, alreadyFoundPdtIt = false, anyGauss=false;
+ bool alreadyFoundAnEntity=false,alreadyFoundPdtIt = false;
int numberOfElements = 0;
int numberOfGeometricType = 0;
- //med_2_2::med_geometrie_element..
MED_EN::medGeometryElement geometricType[MED_NBR_GEOMETRIE_MAILLE];
int numberOfElementsOfType[MED_NBR_GEOMETRIE_MAILLE];
- int numberOfGaussPoint[MED_NBR_GEOMETRIE_MAILLE];
+ numberOfElementsOfTypeC.clear();numberOfGaussPoint.clear();
+ numberOfElementsOfTypeC.resize(MED_NBR_GEOMETRIE_MAILLE+1);
+ numberOfGaussPoint.resize(MED_NBR_GEOMETRIE_MAILLE+1);
med_2_2::med_int nmaa=0, ngauss=0, numdt=-1, numo=-1, nbPdtIt=0;
char dtunit[MED_TAILLE_PNOM22+1];
med_2_2::med_float dt=-1.0;
med_2_2::med_booleen local;
med_2_2::med_err ret=1;
+ numberOfElementsOfTypeC[0] = 1;
+ numberOfGaussPoint[0] = 1;
+ totalNumberOfElWg = 0;
+ /* Détermine le type d'entité et la liste des types géométriques associés
+ au champ <fieldName> */
for (currentEntity = CellAndNodeEntities.begin();
currentEntity != CellAndNodeEntities.end(); currentEntity++) {
for (currentGeometry = (*currentEntity).second.begin();
(med_2_2::med_geometrie_element) *currentGeometry )) <= 0 )
continue;
-
-
+ /* Verifie que le champ n'est pas défini sur un autre type d'entité */
if ( alreadyFoundAnEntity ) {
if (entity != (*currentEntity).first )
throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<" Field |" << fieldName
} else { entity=(*currentEntity).first; alreadyFoundAnEntity = true; };
+ /* Cherche le champ pour le <ndt>,<ot> demandé et détermine le nombre de points de Gauss*/
ret = 0; alreadyFoundPdtIt = false; ngauss =0;
for ( med_2_2::med_int j=1; j <= nbPdtIt; j++ ) {
ret += med_2_2::MEDpasdetempsInfo(id, const_cast <char*> ( fieldName.c_str() ),
(med_2_2::med_entite_maillage) (*currentEntity).first,
(med_2_2::med_geometrie_element) *currentGeometry,
- j, &ngauss, &numdt, &numo, dtunit, &dt,
+ j, &ngauss, &numdt, &numo, dtunit, &dt,
maa, &local, &nmaa);
if ( ndt == numdt && numo == od ) {
<< "is defined on multiple meshes, using dafault mesh |" << maa << "|" );
}
- if ( !local)
- throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<" Field |" << fieldName << "| with (ndt,or) = ("
- << ndt << "," << od << ") for (entityType,geometricType)=("
- << MED_EN::entNames[(*currentEntity).first] << ","
- << MED_EN::geoNames[*currentGeometry] << ")"
- << "is using a mesh on a different file which is not yet supported" ));
+ if ( !local) {
+ MESSAGE(" Field |" << fieldName << "| with (ndt,or) = ("
+ << ndt << "," << od << ") for (entityType,geometricType)=("
+ << MED_EN::entNames[(*currentEntity).first] << ","
+ << MED_EN::geoNames[*currentGeometry] << ")"
+ << "is using a mesh on a distant file (ignored)" );
+
+// throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<" Field |" << fieldName << "| with (ndt,or) = ("
+// << ndt << "," << od << ") for (entityType,geometricType)=("
+// << MED_EN::entNames[(*currentEntity).first] << ","
+// << MED_EN::geoNames[*currentGeometry] << ")"
+// << "is using a mesh on a different file which is not yet supported" ));
+ }
if ( ! meshName.empty() )
if ( meshName != maa ) {
<< MED_EN::entNames[(*currentEntity).first] << ","
<< MED_EN::geoNames[*currentGeometry] << ")" )); ;
- //totalNumberOfElements+=numberOfElements;
numberOfElementsOfType[numberOfGeometricType] = numberOfElements/ngauss;
- numberOfGaussPoint[numberOfGeometricType] = ngauss;
- anyGauss = (anyGauss || (ngauss-1) );
+ numberOfElementsOfTypeC[numberOfGeometricType+1]=
+ numberOfElementsOfTypeC[numberOfGeometricType]
+ + numberOfElementsOfType[numberOfGeometricType];
+ numberOfGaussPoint[numberOfGeometricType+1] = ngauss;
geometricType[numberOfGeometricType]= *currentGeometry;
numberOfGeometricType++;
+ totalNumberOfElWg+=numberOfElements;
} // End Second For
if ( alreadyFoundAnEntity) {
support.setName(fieldName+"Support");
- support.setMeshName(string(maa)); // Vérifier que les différents noms de maillages lus soient identiques
+ support.setMeshName(string(maa)); // Vérifier que les différents noms de maillages lus soient identiques
support.setEntity(entity);
- // REM : Signification précédente erronée pour un champ qui ne repose pas sur toutes les entités géométriques
- // du maillage mais dont le SUPPORT a été crée à partir des informations d'un maillage, comme
- // celà fût la plupart du temps.
+ // REM : Le nombre <numberOfGeometricType> dans la précédente version du Driver
+ // était erronée pour un champ qui ne reposait pas sur toutes les entités géométriques
+ // du maillage mais dont le SUPPORT a été crée à partir des informations du maillage
+ // ( méthode qui était largement utilisée pour construire un SUPPORT).
support.setNumberOfGeometricType(numberOfGeometricType);
- support.setGeometricType(geometricType); // Utile uniquement si setAll == false
- support.setNumberOfElements(numberOfElementsOfType); //setNumberOfElements effectue une copie
+ support.setGeometricType(geometricType); // Utile uniquement si setAll == false ?
+ support.setNumberOfElements(numberOfElementsOfType); //setNumberOfElements effectue une copie
+ // Par défaut considère que le champ repose sur tous les type géométriques du maillage
+ // Si ce n'est pas le cas les champs geometricType et numberOfElementsOfType du SUPPORT sont corrects
support.setAll(true);
- if (anyGauss)
- support.setNumberOfGaussPoint(numberOfGaussPoint);
+ numberOfElementsOfTypeC.resize(numberOfGeometricType+1);
+ numberOfGaussPoint.resize(numberOfGeometricType+1);
return alreadyFoundAnEntity;
} else
return false;
}
+/*!
+
+ Renvoie la liste <geoType> des types géométriques définis dans le maillage <meshName>
+ pour le type d'entité <entity>.
+ * < nbOfElOfType > contient le nombre d'entités de chaque type
+ * < numberOfElementsOfTypeC > contient le nombre d'entités cumulées de chaque type
+ avec numberOfElementsOfTypeC[0]=0;
+
+*/
template <class T> void
-MED_FIELD_DRIVER22<T>::getMeshGeometricType(med_2_2::med_idt id,
+MED_FIELD_DRIVER22<T>::getMeshGeometricTypeFromFile(med_2_2::med_idt id,
string & meshName,
MED_EN::medEntityMesh entity,
vector<MED_EN::medGeometryElement> & geoType,
- vector<int> &nbOfElOfType) const
+ vector<int> &nbOfElOfType,
+ vector<int> &nbOfElOfTypeC
+ ) const throw(MEDEXCEPTION)
{
- const char LOC[] = "MED_FIELD_DRIVER<T>::getMeshGeometricType(...)";
+ const char LOC[] = "MED_FIELD_DRIVER<T>::getMeshGeometricTypeFromFile(...)";
int numberOfGeometricType=0;
MED_EN::medGeometryElement geometricType[MED_NBR_GEOMETRIE_MAILLE];
- int numberOfElementsOfType[MED_NBR_GEOMETRIE_MAILLE];
+ int numberOfElementsOfType [MED_NBR_GEOMETRIE_MAILLE];
+ int numberOfElementsOfTypeC[MED_NBR_GEOMETRIE_MAILLE+1];
med_2_2::med_int numberOfElements=0;
med_2_2::med_table quoi;
if (entity == MED_EN::MED_CELL) quoi=med_2_2::MED_CONN;
list<MED_EN::medGeometryElement>::const_iterator currentGeometry;
bool alreadyFoundAnEntity = false;
+ numberOfElementsOfTypeC[0]=0;
for (currentGeometry = (MED_EN::meshEntities[entity]).begin();
currentGeometry != (MED_EN::meshEntities[entity]).end(); currentGeometry++) {
alreadyFoundAnEntity = true;
numberOfElementsOfType[numberOfGeometricType] = numberOfElements;
+ numberOfElementsOfTypeC[numberOfGeometricType+1] =
+ numberOfElementsOfTypeC[numberOfGeometricType]+numberOfElements;
geometricType[numberOfGeometricType] = *currentGeometry;
numberOfGeometricType++;
}
-
+
geoType = vector<MED_EN::medGeometryElement>(geometricType,geometricType+numberOfGeometricType);
nbOfElOfType = vector<int> (numberOfElementsOfType,numberOfElementsOfType+numberOfGeometricType);
+ nbOfElOfTypeC = vector<int> (numberOfElementsOfTypeC,numberOfElementsOfTypeC+numberOfGeometricType+1);
+
+// for (int j =0 ; j<= numberOfGeometricType;++j)
+// cout << "nbOfElOfTypeC["<<j<<"]="<<nbOfElOfTypeC[j]<<endl;
}
+template <class T> void
+MED_FIELD_DRIVER22<T>::getMeshGeometricTypeFromMESH( MESH * meshPtr,
+ MED_EN::medEntityMesh entity,
+ vector<MED_EN::medGeometryElement> & geoType,
+ vector<int> &nbOfElOfType,
+ vector<int> &nbOfElOfTypeC) const throw(MEDEXCEPTION)
+{
+ const char LOC[] = "MED_FIELD_DRIVER<T>::getMeshGeometricTypeFromMESH(...) : ";
+ BEGIN_OF(LOC);
+
+ if (!meshPtr)
+ throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"ptrMesh must be non null" )); ;
+
+ // Il est plus pratique de créer un support "onAll"
+ // pour calculer les tableaux du nombre d'entités cumulées
+
+ SUPPORT mySupportFromMesh = SUPPORT(meshPtr,"Temporary Support From Associated Mesh",
+ entity);
+ geoType = vector<MED_EN::medGeometryElement>(mySupportFromMesh.getTypes(),
+ mySupportFromMesh.getTypes()+mySupportFromMesh.getNumberOfTypes());
+ nbOfElOfType.resize(mySupportFromMesh.getNumberOfTypes());
+ nbOfElOfTypeC.resize(mySupportFromMesh.getNumberOfTypes()+1);
+ nbOfElOfTypeC[0]=0;
+
+ for (int j=1; j<=mySupportFromMesh.getNumberOfTypes(); ++j) {
+ nbOfElOfType[j-1]=mySupportFromMesh.getNumberOfElements(geoType[j-1]);
+ nbOfElOfTypeC[j]+=nbOfElOfTypeC[j-1]+nbOfElOfType[j-1];
+ }
+
+ END_OF(LOC);
+}
+
/*--------------------- RDONLY PART -------------------------------*/
template <class T> GENDRIVER * MED_FIELD_RDONLY_DRIVER22<T>::copy(void) const
BEGIN_OF(LOC);
typedef typename MEDMEM_ArrayInterface<T,NoInterlace,NoGauss>::Array ArrayNo;
+ typedef typename MEDMEM_ArrayInterface<T,NoInterlace,Gauss>::Array ArrayNoWg;
typedef typename MEDMEM_ArrayInterface<T,FullInterlace,NoGauss>::Array ArrayFull;
+ typedef typename MEDMEM_ArrayInterface<T,FullInterlace,Gauss>::Array ArrayFullWg;
+
+ if (MED_FIELD_DRIVER<T>::_status!=MED_OPENED)
+ throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<": Method open must be called before method read.")) ;
if ( ( MED_FIELD_DRIVER<T>::_fieldName.empty() ) &&
( MED_FIELD_DRIVER<T>::_ptrField->_name.empty() ) )
throw MEDEXCEPTION(LOCALIZED(STRING(LOC)
<<" <fieldName> size in object driver FIELD is > MED_TAILLE_NOM ."));
+ const string & fieldName = MED_FIELD_DRIVER<T>::_fieldName;
- MESSAGE("###### "<<LOC<<" fieldNameDRIVER : "<< MED_FIELD_DRIVER<T>::_fieldName <<
- " fieldName : "<<MED_FIELD_DRIVER<T>::_fieldName);
+ MED_EN::medModeSwitch interlacingType = MED_FIELD_DRIVER<T>::_ptrField->getInterlacingType();
+ bool isFullInterlace = ( interlacingType == MED_EN::MED_FULL_INTERLACE );
-
- if (MED_FIELD_DRIVER<T>::_status!=MED_OPENED)
- throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<": Method open must be called before method read.")) ;
+ MESSAGE("###### "<<LOC<<" fieldNameDRIVER : "<< fieldName << " fieldName : "<< MED_FIELD_DRIVER<T>::_ptrField->_name);
// EF :
-// Si un support a été donnée au champ, pour des raisons de compatibilité avec
-// les versions précédentes, ce support sera utilisé pour
+// Si un support a été donnée au champ, pour des raisons de compatibilité avec
+// les versions précédentes, ce support sera utilisé pour
// - Obtenir le nom du maillage sur lequel on veut lire le champ
// (eventuellement on pourrait l'utiliser pour selectionner un champ qui
-// repose sur plusieurs maillages cf HOMARD-ASTER)
-// - vérifier le type d'entité (MED_NOEUD xor MED_MAILLE xor MED_FACE xor MED_ARETE ) sur lequel
-// il faut lire le champ qui est également retouvé.
-// - Si le support défini une liste d'entité ( différente de MED_ALL_ELEMENTS), celle-ci est ignorée
-// à la lecture et écrasé par les listes de profils lus s'il en existe
-
-// Si aucun support n'a été donné au champ :
-// - A la lecture : Un support est crée et le type d'entité unique est lu
-// (cf decision gt MED qu'un champ repose sur une entité unique ?),
-// l'ensemble des types géométriques est lu,
-// l'ensemble des profils par type géométrique est lu
-// Le nom du maillage associé est lu mais le pointeur SUPPORT-MESH non initialisé
-
- char * fieldName = new char[MED_TAILLE_NOM+1] ;
+// repose sur plusieurs maillages cf HOMARD-ASTER, ce qui n'est pas géré dans MEDMEM)
+// - vérifier le type d'entité (MED_NOEUD xor MED_MAILLE xor MED_FACE xor MED_ARETE ) sur lequel
+// il faut lire le champ qui est également retouvé.
+// - Si le support défini une liste d'entité ( différente de MED_ALL_ELEMENTS), celle-ci est ignorée
+// à la lecture et écrasé par soit :
+// - onall, après avoir vérifié que la liste des types géométriques utilisés par le champ
+// est égale à la liste des type géométriques définis dans le maillage associé
+// pour tous le même type d'entité.
+// - La sous liste des types géométriques utilisés (onAll quand même, cf commenataire ci-dessous )
+// - les listes de profils lus s'il en existe pour une sous liste de types
+// géométriques
+
+// Si aucun support n'a été donné au champ :
+// - A la lecture : Un support est crée et le type d'entité unique est lu
+// (cf decision gt MED qu'un champ repose sur une entité unique ?),
+// l'ensemble des types géométriques est lu,
+// l'ensemble des profils par type géométrique est lu
+// Le nom du maillage associé est lu mais le pointeur SUPPORT-MESH non initialisé
+
+
+ char * tmpFieldName = new char[MED_TAILLE_NOM+1] ;
int err ;
int numberOfComponents = 0;
char * componentName = (char *) MED_NULL;
char * unitName = (char *) MED_NULL;
med_2_2::med_type_champ type ;
med_2_2::med_idt id = MED_FIELD_DRIVER22<T>::_medIdt;
+ bool needConversionToDouble = false,needConversionToInt64 = false;
- // we search for the field med number of <fieldName>
- // Having found <fieldName> variables <numberOfComponents>,
+ // we search for the "field med number" of <fieldName>
+ // Having found <fieldName>, variables <numberOfComponents>,
// <componentName>, <unitname>, <type> and attribute <_fieldNum> are set.
if (MED_FIELD_DRIVER<T>::_fieldNum==MED_INVALID)
{
int numberOfFields = med_2_2::MEDnChamp(id,0) ;
- if ( numberOfFields <= 0 )
+ if ( numberOfFields <= 0 )
throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<": There is no field found in the file !"));
for (int i=1;i<=numberOfFields;i++)
{
numberOfComponents = med_2_2::MEDnChamp(id,i) ;
- if ( numberOfComponents <= 0 )
+ if ( numberOfComponents <= 0 )
MESSAGE(LOC<<"Be careful there is no compound for field n°"<<i<<"in file |"<<MED_FIELD_DRIVER<T>::_fileName<<"| !");
componentName = new char[numberOfComponents*MED_TAILLE_PNOM22+1] ;
- unitName = new char[numberOfComponents*MED_TAILLE_PNOM22+1] ;
-
- err = med_2_2::MEDchampInfo(id, i, fieldName, &type, componentName,
+ unitName = new char[numberOfComponents*MED_TAILLE_PNOM22+1] ;
+
+ err = med_2_2::MEDchampInfo(id, i, tmpFieldName, &type, componentName,
unitName, numberOfComponents) ;
-
- MESSAGE("Field "<<i<<" : #" << fieldName <<"# et recherche #"<<MED_FIELD_DRIVER<T>::_fieldName.c_str()<<"#");
- if ( !strcmp(fieldName,MED_FIELD_DRIVER<T>::_fieldName.c_str()) ) {
- MESSAGE("FOUND FIELD "<< fieldName <<" : "<<i);
+
+ MESSAGE("Field "<<i<<" : #" << tmpFieldName <<"# et recherche #"<<fieldName.c_str()<<"#");
+ if ( !strcmp(tmpFieldName,fieldName.c_str()) ) {
+ MESSAGE("FOUND FIELD "<< tmpFieldName <<" : "<<i);
MED_FIELD_DRIVER<T>::_fieldNum = i ;
break ;
}
delete[] unitName ;
}
}
-
- delete[] fieldName ;
+ delete[] tmpFieldName ;
+
+ // Si aucun champ ne correspond les variables <componentName> et <unitName> ont été correctement
+ // désallouées dans la boucle de recherche
if (MED_FIELD_DRIVER<T>::_fieldNum==MED_INVALID)
- throw MEDEXCEPTION(LOCALIZED( STRING(LOC) << ": Field "<<MED_FIELD_DRIVER<T>::_fieldName << " not found in file " << MED_FIELD_DRIVER<T>::_fileName ) );
+ throw MEDEXCEPTION(LOCALIZED( STRING(LOC) << ": Field "<< fieldName
+ << " not found in file " << MED_FIELD_DRIVER<T>::_fileName) );
+
MESSAGE ("FieldNum : "<<MED_FIELD_DRIVER<T>::_fieldNum);
if (numberOfComponents < 1) {
delete[] componentName; delete[] unitName;
- throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<" no component found fo field "
- << MED_FIELD_DRIVER<T>::_fieldName)) ;
+ throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<" no component found for field "
+ << fieldName)) ;
}
+ // Verifie que l'on essaye pas de lire un champ double dans un FIELD<int>
switch ( (med_2_2::med_type_champ) MED_FIELD_DRIVER<T>::_ptrField->_valueType ) {
case med_2_2::MED_INT :
case med_2_2::MED_INT32 :
<<") differs from FIELD object type (" <<
MED_FIELD_DRIVER<T>::_ptrField->_valueType << ")" )) ;
}
+#if defined(IRIX64) || defined(OSF1) ||defined(VPP5000)
+ if (_ptrField->_valueType==MED_EN::MED_INT32 )
+ needConversionToInt64=true;
+#endif
+ break;
+ case med_2_2::MED_FLOAT64 :
+ if (type != med_2_2::MED_FLOAT64)
+ needConversionToDouble=true;
break;
default:
break;
}
-
string meshName="";
+ MESH * ptrMesh = 0;
bool haveSupport = false;
+ bool haveMesh = false;
if ( MED_FIELD_DRIVER<T>::_ptrField->getSupport() ) {
- // Verif sur la taille du meshName
- meshName = MED_FIELD_DRIVER<T>::_ptrField->getSupport()->getMesh()->getName() ;
+ // Verif à faire sur la taille du meshName
+ ptrMesh = MED_FIELD_DRIVER<T>::_ptrField->getSupport()->getMesh();
+ if ( ptrMesh) {
+ meshName = MED_FIELD_DRIVER<T>::_ptrField->getSupport()->getMesh()->getName() ;
+ haveMesh = true;
+ }
haveSupport = true;
}
- // Cherche le type d'entité, le nombre d'entité par type géométrique sur le type d'entité
- // (MED_MAILLE ou MED_NOEUD uniquement car MEDMEMOIRE ne gère pas la connectivité descendante).
- // et crée le support correspondant.
- SUPPORT * mySupport = new SUPPORT();
- bool found = createFieldSupport(id,MED_FIELD_DRIVER<T>::_fieldName,
- MED_FIELD_DRIVER<T>::_ptrField->_iterationNumber,
- MED_FIELD_DRIVER<T>::_ptrField->_orderNumber,
- *mySupport, meshName) ;
+ // Cherche le type d'entité, le nombre d'entité par type géométrique sur le type d'entité
+ // (MED_MAILLE ou MED_NOEUD uniquement car MEDMEMOIRE ne gère pas la connectivité descendante).
+ // et crée le support correspondant.
+ SUPPORT * mySupport = new SUPPORT();
+ vector<int> numberOfElementsOfTypeC;
+ vector<int> numberOfGaussPoint;
+ int totalNumberOfElWg=0;
+
+ bool found = createFieldSupportPart1(id,fieldName,
+ MED_FIELD_DRIVER<T>::_ptrField->_iterationNumber,
+ MED_FIELD_DRIVER<T>::_ptrField->_orderNumber,
+ *mySupport, meshName,
+ numberOfElementsOfTypeC, numberOfGaussPoint,totalNumberOfElWg);
+
if ( !found ) {
delete mySupport; delete[] componentName; delete[] unitName;
MED_FIELD_DRIVER<T>::_fieldNum = MED_INVALID ;
throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<" Can't find any entity for field |"
- << MED_FIELD_DRIVER<T>::_fieldName
+ << fieldName
<< "| with (it,or) = ("
<< MED_FIELD_DRIVER<T>::_ptrField->_iterationNumber << ","
<< MED_FIELD_DRIVER<T>::_ptrField->_orderNumber << "), on mesh "
<< meshName << "|" ));
}
+
+ MED_EN::medEntityMesh entityType = mySupport->getEntity();
+ //Si un SUPPORT était donné, récupère son nom, sa description et
+ // le pointeur du maillage associé
if (! haveSupport)
meshName = mySupport->getMeshName();
else {
if ( mySupport->getEntity() != MED_FIELD_DRIVER<T>::_ptrField->getSupport()->getEntity() ) {
- MED_EN::medEntityMesh ent = mySupport->getEntity();
delete mySupport; delete[] componentName; delete[] unitName;
MED_FIELD_DRIVER<T>::_fieldNum = MED_INVALID ;
- throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<" Given entity |"
+ throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"Given entity |"
<< MED_EN::entNames[MED_FIELD_DRIVER<T>::_ptrField->
getSupport()->getEntity()]
<< "| for field |"
- << MED_FIELD_DRIVER<T>::_fieldName
+ << fieldName
<< "| with (it,or) = ("
<< MED_FIELD_DRIVER<T>::_ptrField->_iterationNumber << ","
<< MED_FIELD_DRIVER<T>::_ptrField->_orderNumber << "), on mesh "
<< meshName << "| differs from found entity |"
- << MED_EN::entNames[ent] << "|."
+ << MED_EN::entNames[entityType] << "|."
));
}
mySupport->setName( MED_FIELD_DRIVER<T>::_ptrField->getSupport()->getName() );
mySupport->setDescription(MED_FIELD_DRIVER<T>::_ptrField->getSupport()->getDescription());
}
- // Test si le Support du Champ repose ou non sur toutes les entités géométriques du maillage.
- // Pour tester les profils aussi ?
+ vector< MED_EN::medGeometryElement > MESHgeoType;
+ vector< int > MESHnbOfElOfType;
+ vector< int > MESHnbOfElOfTypeC;
+ if ( haveMesh )
+ getMeshGeometricTypeFromMESH(ptrMesh,entityType,MESHgeoType,
+ MESHnbOfElOfType,MESHnbOfElOfTypeC);
+
+ int fileHasMesh = ( med_2_2::MEDdimLire(id, const_cast<char *>(meshName.c_str())) > 0);
vector< MED_EN::medGeometryElement > meshGeoType;
vector< int > meshNbOfElOfType;
- getMeshGeometricType(id,meshName,mySupport->getEntity(),meshGeoType,meshNbOfElOfType);
+ vector< int > meshNbOfElOfTypeC;
+ // Si le maillage n'est pas trouvé les tableaux renvoyés sont vides
+ if (fileHasMesh)
+ getMeshGeometricTypeFromFile(id,meshName,entityType,meshGeoType,
+ meshNbOfElOfType,meshNbOfElOfTypeC);
+
+
+ if (fileHasMesh && haveSupport )
+ if ( ( meshGeoType != MESHgeoType ) || (meshNbOfElOfTypeC != MESHnbOfElOfTypeC) )
+ throw MEDEXCEPTION(LOCALIZED( STRING(LOC) <<": Error while getting mesh information from file for FIELD "<< fieldName
+ << " on entity " << MED_EN::entNames[entityType]
+ << " with (it,or) = ("
+ << MED_FIELD_DRIVER<T>::_ptrField->_iterationNumber << ","
+ << MED_FIELD_DRIVER<T>::_ptrField->_orderNumber << ")"
+ << " on mesh " << meshName
+ << " : geometric types or number of elements by type differs from MESH object !"
+ )
+ );
+
+ if ( !fileHasMesh && !haveSupport )
+ throw MEDEXCEPTION(LOCALIZED( STRING(LOC) <<": Error while getting mesh information for FIELD "<< fieldName
+ << " on entity " << MED_EN::entNames[entityType]
+ << " with (it,or) = ("
+ << MED_FIELD_DRIVER<T>::_ptrField->_iterationNumber << ","
+ << MED_FIELD_DRIVER<T>::_ptrField->_orderNumber << ")"
+ << " on mesh " << meshName
+ << " : SUPPORT must contain a valid MESH reference or file must contain the associated MESH."
+ )
+ );
+
+
+ if (!fileHasMesh && haveSupport) {
+ meshNbOfElOfTypeC = MESHnbOfElOfTypeC;
+ meshGeoType = MESHgeoType;
+ meshNbOfElOfType = MESHnbOfElOfType;
+ }
+
+
+ // Test si le Support du Champ repose ou non sur toutes les entités géométriques
+ // du maillage associé et positionne ou non l'attribut onAll du SUPPORT.
+ // Il ne s'agit pas de la gestion des profils
vector < MED_EN::medGeometryElement > v1( mySupport->getTypes(),
mySupport->getTypes()+mySupport->getNumberOfTypes() );
- vector < int > v2(mySupport->getNumberOfElements(),
- mySupport->getNumberOfElements()+mySupport->getNumberOfTypes() );
- if ( ( meshGeoType != v1 ) || meshNbOfElOfType != v2 ) {
- mySupport->setAll(false);
+ vector<int> v2(numberOfElementsOfTypeC.size());
+ transform(numberOfElementsOfTypeC.begin(),
+ numberOfElementsOfTypeC.end(),v2.begin(), bind2nd(plus<int>(),1));
+
+ if ( ( meshGeoType != v1 ) || meshNbOfElOfTypeC != v2 ) {
+ // ATTENTION : mySupport->setAll(false);
+ // Pb : On a envie de positionner onAll à faux si le champ n'est pas défini sur tous les
+ // types géométriques du maillage associé.
+ // Mais si onAll est false et si aucun profil n'est détecté par la suite,
+ // l'attribut SUPPORT->_number est censé être positionné quand même ! Que faire ?
+ // Si on veut être compatible avec la signification première de onAll,
+ // il faudrait créer des profils contenant toutes les entités pour chaque type géométrique
+ // du SUPPORT mais d'une part c'est dommage d'un point de vue de l'emcombrement mémoire
+ // et d'autre part, à la réécriture du fichier MED on stockera des profils
+ // alors qu'il n'y en avait pas à l'origine (fichier MED différent après lecture/écriture) !
+ // Si on laisse setAll à vrai il faut être sûr que les utilisateurs prennent les
+ // informations sur les types gémétrique au niveau du support et non pas du maillage.
+ // Solution : Signification du onAll -> onAllElements des type géométriques définis
+ // dans le SUPPORT et non du maillage associé (dans la plupart des cas si le fichier ne
+ // contient pas de profil, le champ est défini sur toutes les entités de tous les types
+ // géométriques définis dans le maillage).
}
- //??support->setNumber(MEDSKYLINEARRAY * Number);
- //??support->setNumber(const int * index, const int* value, bool shallowCopy=false);
// If an error occurs while reading the field, these allocated FIELD member will be deleted
- MED_FIELD_DRIVER<T>::_ptrField->_name = MED_FIELD_DRIVER<T>::_fieldName;
- MED_FIELD_DRIVER<T>::_ptrField->_numberOfComponents = numberOfComponents ;
- MED_FIELD_DRIVER<T>::_ptrField->_componentsTypes = new int[numberOfComponents] ;
- MED_FIELD_DRIVER<T>::_ptrField->_componentsNames = new string[numberOfComponents] ;
- MED_FIELD_DRIVER<T>::_ptrField->_componentsUnits = new UNIT[numberOfComponents] ;
+ MED_FIELD_DRIVER<T>::_ptrField->_name = fieldName;
+ MED_FIELD_DRIVER<T>::_ptrField->_numberOfComponents = numberOfComponents ;
+ MED_FIELD_DRIVER<T>::_ptrField->_componentsTypes = new int [numberOfComponents] ;
+ MED_FIELD_DRIVER<T>::_ptrField->_componentsNames = new string[numberOfComponents] ;
+ MED_FIELD_DRIVER<T>::_ptrField->_componentsUnits = new UNIT [numberOfComponents] ;
MED_FIELD_DRIVER<T>::_ptrField->_componentsDescriptions = new string[numberOfComponents] ;
- MED_FIELD_DRIVER<T>::_ptrField->_MEDComponentsUnits = new string[numberOfComponents] ;
-
- for (int i=0; i<numberOfComponents; i++)
- {
+ MED_FIELD_DRIVER<T>::_ptrField->_MEDComponentsUnits = new string[numberOfComponents] ;
+ for (int i=0; i<numberOfComponents; i++) {
MED_FIELD_DRIVER<T>::_ptrField->_componentsTypes[i] = 1 ;
MED_FIELD_DRIVER<T>::_ptrField->_componentsNames[i] = string(componentName,i*MED_TAILLE_PNOM22,MED_TAILLE_PNOM22) ;
SCRUTE(MED_FIELD_DRIVER<T>::_ptrField->_componentsNames[i]);
MED_FIELD_DRIVER<T>::_ptrField->_MEDComponentsUnits[i] = string(unitName,i*MED_TAILLE_PNOM22,MED_TAILLE_PNOM22) ;
SCRUTE(MED_FIELD_DRIVER<T>::_ptrField->_MEDComponentsUnits[i]);
- }
+ }
delete[] componentName;
delete[] unitName;
- int NumberOfTypes = mySupport->getNumberOfTypes() ;
- const MED_EN::medGeometryElement *Types = mySupport->getTypes() ;
- T ** myValues = new T*[NumberOfTypes] ;
- int * NumberOfValues = new int[NumberOfTypes] ;
- int TotalNumberOfValues = 0 ; //profil a gerer en 2.2
- MESSAGE ("NumberOfTypes :"<< NumberOfTypes);
+ int NumberOfTypes = mySupport->getNumberOfTypes() ;
+ const MED_EN::medGeometryElement *types = mySupport->getTypes() ;
+ T * myValues = new T[totalNumberOfElWg*numberOfComponents];
+ const int * nbOfElOfType = mySupport->getNumberOfElements() ;
+ bool anyProfil = false;
+ int pflSize=0,index=0;
+ // Le vecteur de profil est dimensionné par rapport aux nombres de types
+ // géométriques du champ même si le champ n'a pas de profil MED FICHIER sur
+ // tous ses types géométriques car dans MEDMEM si onAllElement
+ // du SUPPORT est false il faut positionner un profil pour tous les types géométriques
+ // du SUPPORT
+ int profilSizeC = 0;
+ vector < int > profilSize (NumberOfTypes,0);
+ vector < vector<int> > profilList (NumberOfTypes);
+ vector < string > profilNameList(NumberOfTypes);
+ char * profilName = new char[MED_TAILLE_NOM+1];
+
+ MESSAGE ("NumberOfTypes : "<< NumberOfTypes);
MED_FIELD_DRIVER<T>::_ptrField->_numberOfValues=0 ;
- for (int i=0; i<NumberOfTypes; i++)
- {
- NumberOfValues[i] = mySupport->getNumberOfElements(Types[i])
- * mySupport->getNumberOfGaussPoint(Types[i]);
- myValues[i] = new T[ NumberOfValues[i]*numberOfComponents ] ;
- TotalNumberOfValues+=NumberOfValues[i] ;
- char * ProfilName = new char[MED_TAILLE_NOM+1];
- char * LocalGaussName = new char[MED_TAILLE_NOM+1];
-
- MESSAGE ("Type["<<i+1<<"] :"<< Types[i]);
- MESSAGE ("Entity :"<<mySupport->getEntity());
- MESSAGE ("NumberOfValues :"<< NumberOfValues[i]);
- MESSAGE ("NumberOfComponents :"<< numberOfComponents);
- MESSAGE ("MESH_NAME :"<< meshName.c_str());
- MESSAGE ("FIELD_NAME :"<< MED_FIELD_DRIVER<T>::_fieldName.c_str());
- MESSAGE ("MED_ENTITE :"<< (med_2_2::med_entite_maillage) mySupport->getEntity());
- MESSAGE("MED_GEOM :"<<(med_2_2::med_geometrie_element)Types[i]);
- MESSAGE("Iteration :"<<MED_FIELD_DRIVER<T>::_ptrField->getIterationNumber());
- MESSAGE("Order :"<<MED_FIELD_DRIVER<T>::_ptrField->getOrderNumber());
-
- MED_FIELD_DRIVER<T>::_ptrField->_numberOfValues+=mySupport->getNumberOfElements(Types[i]); // Ne doit pas prendre en compte les points de Gauss
- med_2_2::med_err ret;
-
-#if defined(IRIX64) || defined(OSF1) || defined(VPP5000)
- int lgth2=NumberOfValues[i]*numberOfComponents;
- if(_ptrField->getValueType()==MED_EN::MED_INT32)
- {
- med_2_2::med_int *temp=new med_2_2::med_int[lgth2];
- ret=med_2_2::MEDchampLire(id,const_cast <char*> (meshName.c_str()),
- const_cast <char*> (MED_FIELD_DRIVER<T>::_fieldName.c_str()),
- (unsigned char*) temp,
- med_2_2::MED_NO_INTERLACE,
- MED_ALL,
- ProfilName,
- (med_2_2::med_entite_maillage) mySupport->getEntity(),
- (med_2_2::med_geometrie_element)Types[i],
- MED_FIELD_DRIVER<T>::_ptrField->getIterationNumber(),
- MED_FIELD_DRIVER<T>::_ptrField->getOrderNumber()
- );
- for(int i2=0;i2<lgth2;i2++)
- myValues[i][i2]=(int)(temp[i2]);
- delete [] temp;
- }
+
+
+ for (int typeNo=0; typeNo<NumberOfTypes; typeNo++) {
+
+ int numberOfValuesWc= nbOfElOfType[typeNo]*numberOfGaussPoint[typeNo+1]*numberOfComponents;
+ char * gaussModelName = new char[MED_TAILLE_NOM+1];
+
+ MESSAGE ("FIELD_NAME : "<< fieldName.c_str());
+ MESSAGE ("MESH_NAME : "<< meshName.c_str());
+ MESSAGE ("MED_ENTITE : "<< MED_EN::entNames[entityType]);
+ MESSAGE ("MED_GEOM : "<< MED_EN::geoNames[types[typeNo]]);
+ MESSAGE ("Iteration : "<< MED_FIELD_DRIVER<T>::_ptrField->getIterationNumber());
+ MESSAGE ("Order : "<< MED_FIELD_DRIVER<T>::_ptrField->getOrderNumber());
+ MESSAGE ("NumberOfElements : "<< nbOfElOfType[typeNo]);
+ MESSAGE ("NumberOfComponents : "<< numberOfComponents);
+ MESSAGE ("NumberOfGaussPts : "<< numberOfGaussPoint[typeNo+1]);
+ MESSAGE ("NumberOfValuesWg : "<< nbOfElOfType[typeNo]*numberOfGaussPoint[typeNo+1]);
+ MESSAGE ("NumberOfValuesWgWc : "<< numberOfValuesWc);
+ MESSAGE ("Index : "<< index);
+ med_2_2::med_err ret=-1;
+
+ med_2_2::med_int * myValuesTmp=0;
+ unsigned char* ptrTmp=0;
+ if (needConversionToDouble || needConversionToInt64 ) {
+ myValuesTmp = new med_2_2::med_int[numberOfValuesWc];
+ ptrTmp = (unsigned char*) myValuesTmp;
+ } else
+ ptrTmp = (unsigned char*) &myValues[index];
+
+ //VERIFIER LE NBRE
+ ret=med_2_2::MEDMEMchampLire(id,const_cast <char*> (meshName.c_str() ),
+ const_cast <char*> (fieldName.c_str()),
+ (unsigned char*) ptrTmp,
+ med_2_2::MED_FULL_INTERLACE,
+ MED_ALL,
+ gaussModelName,
+ profilName,
+ med_2_2::MED_COMPACT,
+ (med_2_2::med_entite_maillage) entityType,
+ (med_2_2::med_geometrie_element)types[typeNo],
+ MED_FIELD_DRIVER<T>::_ptrField->getIterationNumber(),
+ MED_FIELD_DRIVER<T>::_ptrField->getOrderNumber()
+ );
+
+ if (needConversionToDouble || needConversionToInt64 ) {
+
+ if (needConversionToInt64 ) //utiliser un trait
+ for(int i=0;i<numberOfValuesWc;++i)
+ myValues[index+i]=(int)(myValuesTmp[i]);
else
-#endif
- //VERIFIER LE NBRE
- ret=med_2_2::MEDchampLire(id,const_cast <char*> (meshName.c_str()),
- const_cast <char*> (MED_FIELD_DRIVER<T>::_fieldName.c_str()),
- (unsigned char*) myValues[i],
- med_2_2::MED_NO_INTERLACE,
- MED_ALL,
- LocalGaussName,
- ProfilName,
- med_2_2::MED_COMPACT,
- (med_2_2::med_entite_maillage) mySupport->getEntity(),
- (med_2_2::med_geometrie_element) Types[i],
- MED_FIELD_DRIVER<T>::_ptrField->getIterationNumber(),
- MED_FIELD_DRIVER<T>::_ptrField->getOrderNumber()
- );
- if (ret < 0)
- {
- // The Field can't be read then we mustdelete all previously allocated members in FIELD
- for(int j=0; j<=i;j++)
- delete[] myValues[j];
- delete[] myValues;
- delete[] NumberOfValues ;
- delete[] ProfilName;
- delete[] LocalGaussName;
- delete[] MED_FIELD_DRIVER<T>::_ptrField->_componentsTypes ;
- delete[] MED_FIELD_DRIVER<T>::_ptrField->_componentsNames ;
- delete[] MED_FIELD_DRIVER<T>::_ptrField->_componentsUnits ;
- delete[] MED_FIELD_DRIVER<T>::_ptrField->_componentsDescriptions ;
- delete[] MED_FIELD_DRIVER<T>::_ptrField->_MEDComponentsUnits ;
- MED_FIELD_DRIVER<T>::_ptrField->_componentsTypes = NULL ;
- MED_FIELD_DRIVER<T>::_ptrField->_componentsNames = NULL ;
- MED_FIELD_DRIVER<T>::_ptrField->_componentsUnits = NULL ;
- MED_FIELD_DRIVER<T>::_ptrField->_componentsDescriptions = NULL ;
- MED_FIELD_DRIVER<T>::_ptrField->_MEDComponentsUnits = NULL ;
- MED_FIELD_DRIVER<T>::_fieldNum = MED_INVALID ; // we have not found right field, so reset the field number
- throw MEDEXCEPTION( LOCALIZED( STRING(LOC) <<": ERROR when read value")) ;
- }
+ for(int i=0;i<numberOfValuesWc;++i)
+ myValues[index+i]=myValuesTmp[i];
+ delete[] myValuesTmp;
+ }
- delete[] ProfilName ;
- delete[] LocalGaussName ;
+ if (ret < 0)
+ {
+ // The Field can't be read then we must delete all previously allocated members in FIELD
+ //for(int j=0; j<=i;j++)
+ // delete[] myValues[j];
+ delete[] myValues;
+ //delete[] NumberOfValues ;
+ delete[] profilName;
+ delete[] gaussModelName;
+ delete[] MED_FIELD_DRIVER<T>::_ptrField->_componentsTypes ;
+ delete[] MED_FIELD_DRIVER<T>::_ptrField->_componentsNames ;
+ delete[] MED_FIELD_DRIVER<T>::_ptrField->_componentsUnits ;
+ delete[] MED_FIELD_DRIVER<T>::_ptrField->_componentsDescriptions ;
+ delete[] MED_FIELD_DRIVER<T>::_ptrField->_MEDComponentsUnits ;
+ MED_FIELD_DRIVER<T>::_ptrField->_componentsTypes = NULL ;
+ MED_FIELD_DRIVER<T>::_ptrField->_componentsNames = NULL ;
+ MED_FIELD_DRIVER<T>::_ptrField->_componentsUnits = NULL ;
+ MED_FIELD_DRIVER<T>::_ptrField->_componentsDescriptions = NULL ;
+ MED_FIELD_DRIVER<T>::_ptrField->_MEDComponentsUnits = NULL ;
+ MED_FIELD_DRIVER<T>::_fieldNum = MED_INVALID ; // we have not found right field, so reset the field number
+ throw MEDEXCEPTION( LOCALIZED( STRING(LOC) <<": ERROR while reading values")) ;
+ }
+ index += numberOfValuesWc;
+ // Le support prend en compte le nombre de valeurs lié aux profils
+ MED_FIELD_DRIVER<T>::_ptrField->_numberOfValues+=
+ nbOfElOfType[typeNo];// Ne doit pas prendre en compte les points de Gauss
+
+ // second et troisième test lié à un bug medfichier
+ if ( strcmp(gaussModelName,MED_NOGAUSS) && strcmp(gaussModelName,string(MED_TAILLE_NOM,' ').c_str() )
+ && strcmp(gaussModelName,string(16,' ').c_str() ) ) {
+
+ int type_geo = (int) types[typeNo];
+ int t1 = (type_geo%100)*(type_geo/100);
+ int ngauss = numberOfGaussPoint[typeNo+1];
+ int t2 = ngauss*(type_geo/100);
+ med_2_2::med_float * refcoo = new med_2_2::med_float[t1];
+ med_2_2::med_float * gscoo = new med_2_2::med_float[t2];
+ med_2_2::med_float * wg = new med_2_2::med_float[ngauss];
+
+ if (MEDgaussLire(id, refcoo, gscoo, wg, (med_2_2::med_mode_switch) interlacingType,
+ gaussModelName ) < 0)
+ throw MEDEXCEPTION(LOCALIZED( STRING(LOC) <<": Error while reading Gauss Model |"
+ << gaussModelName << "| for FIELD "<< fieldName
+ << " on geometric type " << MED_EN::geoNames[types[typeNo]]
+ )
+ );
+ if (isFullInterlace ) { //serait inutile avec un driver template du type d'entrelacement
+ GAUSS_LOCALIZATION<FullInterlace> * loc;
+ loc = new GAUSS_LOCALIZATION<FullInterlace>(gaussModelName,types[typeNo],ngauss, refcoo,gscoo, wg);
+ MED_FIELD_DRIVER<T>::_ptrField->_gaussModel[types[typeNo]]=loc;
+ } else {
+ GAUSS_LOCALIZATION<NoInterlace> * loc;
+ loc = new GAUSS_LOCALIZATION<NoInterlace>(gaussModelName,types[typeNo],ngauss, refcoo,gscoo, wg);
+ MED_FIELD_DRIVER<T>::_ptrField->_gaussModel[types[typeNo]]=loc;
+ }
+// cout << *MED_FIELD_DRIVER<T>::_ptrField->_gaussModel[types[typeNo]] << endl;
+ delete [] refcoo;delete [] gscoo; delete [] wg;
}
+ delete[] gaussModelName ;
+
+ if ( strcmp(profilName,MED_NOPFL) ) {
+ anyProfil = true;
+ pflSize = med_2_2::MEDnValProfil(id,profilName);
+ if ( pflSize <= 0)
+ throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<" Error while reading the profil size of |"
+ << profilName << "|" ));
+
+ profilSize[typeNo]=pflSize;
+ profilList[typeNo].resize(pflSize);
+ ret = med_2_2::MEDprofilLire(id,&profilList[typeNo][0],profilName); // cf item 16 Effective STL
+ profilNameList[typeNo]=string(profilName);
+ }
+ }
- // allocate _value
- // Créer un driver spécifique pour les modes MED_FULL_INTERLACE et MED_NO_INTERLACE
- // serait plus efficicace.
- ArrayNo * Values = new ArrayNo(numberOfComponents,TotalNumberOfValues);
+ delete[] profilName ;
- for (int i=0; i<numberOfComponents; i++)
- {
- //T * ValuesT = Values->getRow(i+1) ;
- int Count = 1 ;
- for (int j=0; j<NumberOfTypes; j++) {
- T * myValue = myValues[j] ;
- int NumberOf = NumberOfValues[j] ;
- // MED_FIELD_DRIVER<T>::_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] ;
- Values->setIJ(Count,i+1,myValue[k+offset]);
-// SCRUTE(Count);
-// SCRUTE(Values->getIJ(Count,i+1));
- Count++;
- }
+ //MESSAGE ("Index : "<< index);
+ assert(index == totalNumberOfElWg*numberOfComponents);
+ assert(MED_FIELD_DRIVER<T>::_ptrField->_numberOfValues == mySupport->getNumberOfElements(MED_ALL_ELEMENTS));
+
+ if (anyProfil) {
+
+ for (int typeNo=0; typeNo < NumberOfTypes; typeNo++) {
+
+ // Trouve l'index du type géométrique dans la liste des types géométriques du maillage
+ // correspondant au type géométrique du champ traité
+ vector<MED_EN::medGeometryElement>::iterator meshTypeNoIt =
+ find(meshGeoType.begin(),meshGeoType.end(),types[typeNo]); //Gérer l'exception
+ if ( meshTypeNoIt == meshGeoType.end() )
+ throw MEDEXCEPTION(LOCALIZED( STRING(LOC) <<": Can't find "<< MED_EN::geoNames[types[typeNo]]
+ << " on entity " << MED_EN::entNames[entityType]
+ << " in geometric type list of mesh " << meshName
+ )
+ );
+ int meshTypeNo = meshTypeNoIt - meshGeoType.begin();
+
+ if (! profilList[typeNo].empty() ) {
+
+// for (int j =0 ; j< meshGeoType.size();++j)
+// cout << "--MeshTypeNo : "<<meshTypeNo<<"-> meshNbOfElOfTypeC["<<j<<"]="<<meshNbOfElOfTypeC[j]<<endl;
+// cout << "--typeNo--" << typeNo << endl;
+// cout << "meshNbOfElOfTypeC["<<meshTypeNo<<"]=" << meshNbOfElOfTypeC[meshTypeNo] <<endl;
+
+ // Transformer les numéros locaux d'entités medfichier en numéro global medmémoire
+ for (int i = 0 ; i < profilList[typeNo].size(); i++ ) {
+ // Les numéros des entités commencent à 1 dans MEDfichier comme dans MEDmémoire
+ // meshNbOfElOfTypeC[0]=0 ...meshNbOfEltOfTypeC[meshTypeNo]=
+ // meshNbOfElOfTypeC[meshTypeNo-1]+nbrOfElem of meshTypeNo type
+ // rem1 : Si le meshTypeNo trouvé est 0 (premier type géométrique du maillage
+ // il ne faut pas décaler les numéros du profils qui commencent à 1 dans MEDFICHIER
+ // rem2 : meshNbOfElOfTypeC[NumberOfTypes] ne devrait jamais être utilisé
+ profilList[typeNo][i]+=meshNbOfElOfTypeC[meshTypeNo];
+ }
+ } else {
+ // Créer le profil <MED_ALL> pour ce type géométrique
+ // uniquement pour renseigner le tableau skyline avec des accesseurs directs
+ // par type géométriques
+ // REM : Une conséquence est qu'à la réecriture le fichier contiendra des
+ // profils sur certains types géométriques alors qu'à la lecture il n'y en avait pas !
+ // Solution : Stocker les noms des profils et les utiliser pour savoir si il y avait ou non
+ // un profil
+ int pflSize = meshNbOfElOfType[meshTypeNo];
+ // profil = new int[pflSize];
+
+ profilList[typeNo].resize(pflSize);
+ profilSize[typeNo]=pflSize;
+
+ for (int j = 1; j <= pflSize; j++) {
+ profilList[typeNo][j-1]=meshNbOfElOfTypeC[meshTypeNo] + j ; // index MEDMEM commence à 1
+ }
+ profilNameList[typeNo] = MED_NOPFL; //Information a utiliser pour la sauvegarde : PLUTOT MED_ALL
}
+ profilSizeC+=profilList[typeNo].size();
}
-
- for (int j=0; j<NumberOfTypes; j++)
- delete[] myValues[j] ;
- delete[] myValues ;
- delete[] NumberOfValues ;
+ MEDSKYLINEARRAY * skyLine = new MEDSKYLINEARRAY(profilList.size(), profilSizeC );
+ vector<int> index(NumberOfTypes+1,0);
+ index[0]=1;
+ for( int typeNo=0; typeNo < NumberOfTypes; typeNo++ )
+ index[typeNo+1]=index[typeNo]+profilSize[typeNo];
+ skyLine->setIndex(&index[0]);
+ for (int i=1; i <= profilList.size() ; i++)
+ skyLine->setI(i,&profilList[i-1][0]);
+
+ mySupport->setAll(false);
+ mySupport->setpartial(skyLine,true);
+ mySupport->setProfilNames(profilNameList);
+// cout << "Valeurs du skyline du SUPPORT partiel crée : " << *skyLine << endl;
+ }
+
+ // Créer un driver spécifique pour les modes MED_FULL_INTERLACE et MED_NO_INTERLACE
+ // serait plus efficace.
+ bool anyGauss = (numberOfGaussPoint != vector<int>(numberOfGaussPoint.size(),1));
+ SCRUTE(anyGauss);
+ MEDMEM_Array_ * Values;
+ if (anyGauss) {
+ SCRUTE(mySupport->getNumberOfElements(MED_ALL_ELEMENTS) );
+ SCRUTE(NumberOfTypes);
+ SCRUTE(numberOfElementsOfTypeC[NumberOfTypes]-1);
+ assert(mySupport->getNumberOfElements(MED_ALL_ELEMENTS) == (numberOfElementsOfTypeC[NumberOfTypes]-1) );
+ Values = new ArrayFullWg(myValues,
+ numberOfComponents,
+ numberOfElementsOfTypeC[NumberOfTypes]-1,
+ // Up : Prend en compte les profils et
+ // Ne prend pas en compte le nbre de composantes et
+ // le nombre de points de Gauss
+ NumberOfTypes,
+ &numberOfElementsOfTypeC[0],
+ &numberOfGaussPoint[0],
+ true,true);
+// cout << "Valeurs du ArrayFullWg crée : " << endl <<
+// *(static_cast<ArrayFullWg*>(Values)) << endl;
+ } else
+ Values = new ArrayFull(myValues,numberOfComponents,totalNumberOfElWg,
+ true,true);
if (MED_FIELD_DRIVER<T>::_ptrField->_value != NULL)
delete MED_FIELD_DRIVER<T>::_ptrField->_value;
- if ( MED_FIELD_DRIVER<T>::_ptrField->getInterlacingType() == MED_EN::MED_FULL_INTERLACE )
+ if ( MED_FIELD_DRIVER<T>::_ptrField->getInterlacingType() == MED_EN::MED_NO_INTERLACE )
{
- // dynamic_cast inutile
- MED_FIELD_DRIVER<T>::_ptrField->_value=dynamic_cast<ArrayFull *>(ArrayConvert(*Values));
+ if (Values->getGaussPresence())
+ MED_FIELD_DRIVER<T>::_ptrField->_value=ArrayConvert(*static_cast<ArrayFullWg*>(Values));
+ else
+ MED_FIELD_DRIVER<T>::_ptrField->_value=ArrayConvert(*static_cast<ArrayNo* >(Values));
delete Values;
}
else
MED_FIELD_DRIVER<T>::_ptrField->_value=Values;
MED_FIELD_DRIVER<T>::_ptrField->_isRead = true ;
-
- MED_FIELD_DRIVER<T>::_ptrField->_support=mySupport; //Prévenir l'utilisateur ?
-
+
+ MED_FIELD_DRIVER<T>::_ptrField->_support=mySupport; //Prévenir l'utilisateur ?
+
+
END_OF(LOC);
}
{
const char * LOC = "MED_FIELD_WRONLY_DRIVER22::write(void) const " ;
BEGIN_OF(LOC);
-
- typedef typename MEDMEM_ArrayInterface<T,NoInterlace,NoGauss>::Array ArrayNo;
+ typedef typename MEDMEM_ArrayInterface<T,NoInterlace,NoGauss>::Array ArrayNo;
+ typedef typename MEDMEM_ArrayInterface<T,NoInterlace,Gauss>::Array ArrayNoWg;
typedef typename MEDMEM_ArrayInterface<T,FullInterlace,NoGauss>::Array ArrayFull;
+ typedef typename MEDMEM_ArrayInterface<T,FullInterlace,Gauss>::Array ArrayFullWg;
- if (MED_FIELD_DRIVER<T>::_status==MED_OPENED)
- {
- int err ;
-
- int component_count=MED_FIELD_DRIVER<T>::_ptrField->getNumberOfComponents();
- string component_name(component_count*MED_TAILLE_PNOM22,' ') ;
- string component_unit(component_count*MED_TAILLE_PNOM22,' ') ;
-
- const string * listcomponent_name=MED_FIELD_DRIVER<T>::_ptrField->getComponentsNames() ;
- const string * listcomponent_unit=MED_FIELD_DRIVER<T>::_ptrField->getMEDComponentsUnits() ;
- int length ;
- for (int i=0; i < component_count ; i++) {
- length = min(MED_TAILLE_PNOM22,(int)listcomponent_name[i].size());
- component_name.replace(i*MED_TAILLE_PNOM22,length,
- listcomponent_name[i],0,length);
- length = min(MED_TAILLE_PNOM22,(int)listcomponent_unit[i].size());
- component_unit.replace(i*MED_TAILLE_PNOM22,length,
- listcomponent_unit[i],0,length);
- }
+ typedef map<MED_EN::medGeometryElement,GAUSS_LOCALIZATION<FullInterlace>*> locMapFull;
+ typedef map<MED_EN::medGeometryElement,GAUSS_LOCALIZATION<NoInterlace>*> locMapNo;
+ typedef map<MED_EN::medGeometryElement,GAUSS_LOCALIZATION_*> locMap;
- MESSAGE("component_name=|"<<component_name<<"|");
- MESSAGE("component_unit=|"<<component_unit<<"|");
-
- MED_EN::med_type_champ ValueType=MED_FIELD_DRIVER<T>::_ptrField->getValueType() ;
-
- MESSAGE("Template Type =|"<<ValueType<<"|");
-
- // le champ existe deja ???
- char * champName = new char[MED_TAILLE_NOM+1] ;
- med_2_2::med_type_champ type ;
- char * compName ;
- char * compUnit ;
- bool Find = false ;
- int n = med_2_2::MEDnChamp(MED_FIELD_DRIVER22<T>::_medIdt,0);
- int nbComp ;
- for (int i=1; i<=n; i++) {
- nbComp = med_2_2::MEDnChamp(MED_FIELD_DRIVER22<T>::_medIdt,i);
- compName = new char[MED_TAILLE_PNOM22*nbComp+1];
- compUnit = new char[MED_TAILLE_PNOM22*nbComp+1];
- err = med_2_2::MEDchampInfo(MED_FIELD_DRIVER22<T>::_medIdt,i,champName,&type,compName,compUnit,nbComp);
- if (err == 0)
- if (strcmp(champName,MED_FIELD_DRIVER<T>::_ptrField->getName().c_str())==0) { // Found !
- Find = true ;
- break ;
- }
- delete[] compName ;
- delete[] compUnit ;
- }
- delete[] champName ;
- if (Find) {
- // the same ?
- if (nbComp != component_count)
- throw MEDEXCEPTION( LOCALIZED (STRING(LOC)
- <<": Field exist in file, but number of component are different : "<<nbComp<<" in file and "<<component_count<<" in memory."
- )
- );
- // component name and unit
- MESSAGE(LOC<<" Component name in file : "<<compName);
- MESSAGE(LOC<<" Component name in memory : "<<component_name);
- MESSAGE(LOC<<" Component unit in file : "<<compUnit);
- MESSAGE(LOC<<" Component unit in memory : "<<component_unit);
- delete[] compName ;
- delete[] compUnit ;
+ med_2_2::med_idt id = MED_FIELD_DRIVER22<T>::_medIdt;
- } else {
- // Verify the field doesn't exist
-
- string dataGroupName = "/CHA/";
- dataGroupName += MED_FIELD_DRIVER<T>::_ptrField->getName();
- MESSAGE(LOC << "|" << dataGroupName << "|" );
- med_2_2::med_idt gid = H5Gopen(MED_FIELD_DRIVER22<T>::_medIdt, dataGroupName.c_str() );
-
- if ( gid < 0 ) {
- // create field :
- err=med_2_2::MEDchampCr(MED_FIELD_DRIVER22<T>::_medIdt,
- const_cast <char*> ((MED_FIELD_DRIVER<T>::_ptrField->getName()).c_str()),
- (med_2_2::med_type_champ) ValueType,
- const_cast <char*> ( component_name.c_str() ),
- const_cast <char*> ( component_unit.c_str() ),
- component_count);
- if ( err < 0 )
- throw MEDEXCEPTION( LOCALIZED (STRING(LOC)
- << ": Error MEDchampCr : "<<err
- )
- );
- }
- else H5Gclose(gid);
- }
+ if (MED_FIELD_DRIVER<T>::_status!=MED_OPENED)
+ throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<": Method open must be called before method read.")) ;
+
+ string fieldName;
+ if ( ( MED_FIELD_DRIVER<T>::_fieldName.empty() ) &&
+ ( MED_FIELD_DRIVER<T>::_ptrField->_name.empty() ) )
+ throw MEDEXCEPTION(LOCALIZED(STRING(LOC)
+ <<" neither <fieldName> is set in driver nor in object FIELD.")) ;
+
+ // If _fieldName is not set in driver, try to use _ptrfield->_fieldName
+ if ( ( MED_FIELD_DRIVER<T>::_fieldName.empty() ) &&
+ ( !MED_FIELD_DRIVER<T>::_ptrField->_name.empty() ) )
+ fieldName=MED_FIELD_DRIVER<T>::_ptrField->_name;
+ else
+ fieldName = MED_FIELD_DRIVER<T>::_fieldName;
- const SUPPORT * mySupport = MED_FIELD_DRIVER<T>::_ptrField->getSupport() ;
+ SCRUTE(fieldName);
+ if ( fieldName.size() > MED_TAILLE_NOM ) {
+ fieldName.substr(0,MED_TAILLE_NOM);
+ MESSAGE( "Be careful <fieldName> size must not be > MED_TAILLE_NOM, using fieldName : |"<< fieldName <<"|." );
+ }
+
+ const SUPPORT * mySupport = MED_FIELD_DRIVER<T>::_ptrField->getSupport() ;
+ if ( ! mySupport )
+ throw MEDEXCEPTION(LOCALIZED(STRING(LOC)
+ <<" There is no SUPPORT associated with FIELD : "
+ << fieldName << "."));
+
+ bool onAll = mySupport->isOnAllElements();
+ const locMap & gaussModel = MED_FIELD_DRIVER<T>::_ptrField->_gaussModel;
+
+
+ string meshName = mySupport->getMeshName();
+ SCRUTE(meshName);
+ if ( meshName.size() > MED_TAILLE_NOM ) {
+ meshName = meshName.substr(0,MED_TAILLE_NOM);
+ MESSAGE( "Be careful <meshName> size must not be > MED_TAILLE_NOM, using meshName : |"<< meshName <<"|." );
+ }
+ MED_EN::medEntityMesh entityType = mySupport->getEntity();
- if (! mySupport->isOnAllElements())
- throw MEDEXCEPTION( LOCALIZED (STRING(LOC)
- <<": Field must be on all entity"
+ // Reconstruit les listes contigues des noms de composantes et des unités
+ // Les noms sont tronqués à MED_TAILLE_PNOM22
+ int err ;
+ int component_count=MED_FIELD_DRIVER<T>::_ptrField->getNumberOfComponents();
+ string component_name(component_count*MED_TAILLE_PNOM22,' ') ;
+ string component_unit(component_count*MED_TAILLE_PNOM22,' ') ;
+
+ const string * listcomponent_name=MED_FIELD_DRIVER<T>::_ptrField->getComponentsNames() ;
+ const string * listcomponent_unit=MED_FIELD_DRIVER<T>::_ptrField->getMEDComponentsUnits() ;
+ int length ;
+ for (int i=0; i < component_count ; i++) {
+ length = min(MED_TAILLE_PNOM22,(int)listcomponent_name[i].size());
+ component_name.replace(i*MED_TAILLE_PNOM22,length,
+ listcomponent_name[i],0,length);
+ length = min(MED_TAILLE_PNOM22,(int)listcomponent_unit[i].size());
+ component_unit.replace(i*MED_TAILLE_PNOM22,length,
+ listcomponent_unit[i],0,length);
+ }
+
+ MESSAGE("using component_name=|"<<component_name<<"|");
+ MESSAGE("using component_unit=|"<<component_unit<<"|");
+
+ MED_EN::med_type_champ ValueType=MED_FIELD_DRIVER<T>::_ptrField->getValueType() ;
+
+ MESSAGE("Template Type =|"<<ValueType<<"|");
+
+ // Vérifier si le champ existe déjà
+ char champName[MED_TAILLE_NOM+1];
+ char * compName, * compUnit ;
+ med_2_2::med_type_champ type ;
+ bool Find = false ;
+ int n = med_2_2::MEDnChamp(id,0);
+ int nbComp = 0;
+ for (int i=1; i<=n; i++) {
+ nbComp = med_2_2::MEDnChamp(id,i);
+ compName = new char[MED_TAILLE_PNOM22*nbComp+1];
+ compUnit = new char[MED_TAILLE_PNOM22*nbComp+1];
+ err = med_2_2::MEDchampInfo(id,i,champName,&type,compName,compUnit,nbComp);
+ if (err == 0)
+ if (!strcmp(champName,fieldName.c_str()) ) {
+ Find = true ;
+ break ;
+ }
+ delete[] compName ;
+ delete[] compUnit ;
+ }
+
+ if (Find) {
+ // the same ?
+ if (nbComp != component_count)
+ throw MEDEXCEPTION( LOCALIZED (STRING(LOC)
+ <<": Field exist in file, but number of component are different : "
+ <<nbComp<<" in file and "
+ <<component_count<<" in memory."
+ )
+ );
+ // component name and unit
+ SCRUTE(nbComp);
+ MESSAGE(LOC<<" Component name in file : "<<compName);
+ MESSAGE(LOC<<" Component name in memory : "<<component_name);
+ MESSAGE(LOC<<" Component unit in file : "<<compUnit);
+ MESSAGE(LOC<<" Component unit in memory : "<<component_unit);
+ delete[] compName ;
+ delete[] compUnit ;
+
+ } else {
+ // Verify the field isn't yet created
+
+ string dataGroupName = "/CHA/";
+ dataGroupName += fieldName;
+ MESSAGE(LOC << "|" << dataGroupName << "|" );
+ med_2_2::med_idt gid = H5Gopen(id, dataGroupName.c_str() );
+
+ if ( gid < 0 ) {
+ // create field :
+ err=med_2_2::MEDchampCr(id,
+ const_cast <char*> (fieldName.c_str()),
+ (med_2_2::med_type_champ) ValueType,
+ const_cast <char*> ( component_name.c_str() ),
+ const_cast <char*> ( component_unit.c_str() ),
+ component_count);
+ if ( err < 0 )
+ throw MEDEXCEPTION( LOCALIZED (STRING(LOC)
+ << ": Error MEDchampCr : "<<err
)
);
-
- MESH * myMesh = mySupport->getMesh() ;
- string MeshName = myMesh->getName() ;
- //MED_EN::medModeSwitch Mode = MED_FIELD_DRIVER<T>::_ptrField->_value->getMode() ;
- // on boucle sur tout les types pour ecrire les tableaux de valeur
- int NumberOfType = mySupport->getNumberOfTypes() ;
- int Index = 1 ;
- const MED_EN::medGeometryElement * Types = mySupport->getTypes() ;
- const int * NumberOfGaussPoint = mySupport->getNumberOfGaussPoint() ;
-
- const T * value = NULL;
- ArrayFull * myArray = NULL;
- if ( MED_FIELD_DRIVER<T>::_ptrField->getInterlacingType() == MED_EN::MED_FULL_INTERLACE )
- myArray = MED_FIELD_DRIVER<T>::_ptrField->getArrayNoGauss();
- else
- {
- // En attendant la convertion de FIELD, on utilise le ArrayConvert
- // ( les infos _ptrField-> sont les mêmes )
- myArray = ArrayConvert( *( dynamic_cast< ArrayNo * >
- (MED_FIELD_DRIVER<T>::_ptrField->getArrayNoGauss()
- ))
- );
- }
+ }
+ else H5Gclose(gid);
+ }
- for (int i=0;i<NumberOfType;i++)
- {
- int NumberOfElements = mySupport->getNumberOfElements(Types[i]) ;
-
- //value = MED_FIELD_DRIVER<T>::_ptrField->getRow(Index) ;
- value = myArray->getRow(Index) ;
-
- MESSAGE("MED_FIELD_DRIVER22<T>::_medIdt : "<<MED_FIELD_DRIVER22<T>::_medIdt);
- MESSAGE("MeshName.c_str() : "<<MeshName.c_str());
- MESSAGE("MED_FIELD_DRIVER<T>::_ptrField->getName() : "<<MED_FIELD_DRIVER<T>::_ptrField->getName());
- MESSAGE("value : "<<value);
- MESSAGE("NumberOfElements : "<<NumberOfElements);
- MESSAGE("NumberOfGaussPoint[i] : "<<NumberOfGaussPoint[i]);
- MESSAGE("mySupport->getEntity() : "<<mySupport->getEntity());
- MESSAGE("Types[i] : "<<Types[i]);
- MESSAGE("MED_FIELD_DRIVER<T>::_ptrField->getIterationNumber() : "<<MED_FIELD_DRIVER<T>::_ptrField->getIterationNumber());
- MESSAGE("MED_FIELD_DRIVER<T>::_ptrField->getTime() : "<<MED_FIELD_DRIVER<T>::_ptrField->getTime());
- MESSAGE("MED_FIELD_DRIVER<T>::_ptrField->getOrderNumber() : "<<MED_FIELD_DRIVER<T>::_ptrField->getOrderNumber());
-
-/* char chanom[MED_TAILLE_NOM+1];
- char chacomp[MED_TAILLE_NOM+1];
- char chaunit[MED_TAILLE_NOM+1];
- med_2_2::med_type_champ chatype;
- med_int chancomp=1;
-
- err=med_2_2::MEDchampInfo(MED_FIELD_DRIVER22<T>::_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_2_2::MED_REEL64 = "<<med_2_2::MED_REEL64<<endl;
-*/
-
-// err=med_2_2::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_2_2::MED_FULL_INTERLACE,
-// NumberOfElements,
-// NumberOfGaussPoint[i],
-// MED_ALL,
-// MED_NOPFL,
-// med_2_2::MED_REMP, // PROFIL NON GERE, mode de remplacement non géré
-// (med_2_2::med_entite_maillage)mySupport->getEntity(),
-// (med_2_2::med_geometrie_element)Types[i],
-// _ptrField->getIterationNumber(),
-// " ",
-// _ptrField->getTime(),
-// _ptrField->getOrderNumber()
-// );
-
- err=med_2_2::MEDchampEcr(MED_FIELD_DRIVER22<T>::_medIdt,
- const_cast <char*> ( MeshName.c_str()) , //( string(mesh_name).resize(MED_TAILLE_NOM).c_str())
- const_cast <char*> ( (MED_FIELD_DRIVER<T>::_ptrField->getName()).c_str()),
- (unsigned char*)value,
- med_2_2::MED_FULL_INTERLACE,
- NumberOfElements*NumberOfGaussPoint[i],
- MED_NOGAUSS, MED_ALL, MED_NOPFL,
- med_2_2::MED_NO_PFLMOD, // PROFIL NON GERE, mode de remplacement non géré
- (med_2_2::med_entite_maillage)mySupport->getEntity(),
- (med_2_2::med_geometrie_element)Types[i],
- MED_FIELD_DRIVER<T>::_ptrField->getIterationNumber(),
- " ",
- MED_FIELD_DRIVER<T>::_ptrField->getTime(),
- MED_FIELD_DRIVER<T>::_ptrField->getOrderNumber()
- );
- if (err < MED_VALID )
- {
- if ( MED_FIELD_DRIVER<T>::_ptrField->getInterlacingType() == MED_EN::MED_NO_INTERLACE ) delete myArray;
- throw MEDEXCEPTION(LOCALIZED( STRING(LOC)
- <<": Error in writing Field "<< MED_FIELD_DRIVER<T>::_ptrField->getName() <<", type "<<Types[i]
- )
+
+ // On s'assure que le champ est dans le bon type d'entrelacement.
+ // REM : Il faudrait un driver par type d'entrelacement, ce qui eviterait
+ // de doubler l'utilisation de la taille mémoire si le champ n'est pas dans
+ // le bon mode.
+ FIELD<T,FullInterlace> * myField = 0;
+ if ( MED_FIELD_DRIVER<T>::_ptrField->getInterlacingType() == MED_EN::MED_FULL_INTERLACE )
+ myField = MED_FIELD_DRIVER<T>::_ptrField;
+ else
+ myField = FieldConvert( *( dynamic_cast< FIELD<T,NoInterlace> * > (MED_FIELD_DRIVER<T>::_ptrField )
+ )
+ );
+
+
+ // Il est necessaire de calculer le tableau
+ // du nombre d'entités cumulées de chaque type géométrique du maillage
+ // pour convertir les profils de la numérotation globale
+ // à la numérotation locale au type géométrique.
+ // Pour celà on établit ce tableau à partir de l'objet MESH si la relation SUPPORT-MESH existe.
+ // Si le maillage existe dans le fichier MED on essaye également de reconstituer ce tableau
+ // pour vérifier la cohérence des informations.
+ // Si la relation SUPPRT-MESH n'esiste pas on constitue le tableau uniquement à partir du fichier qui
+ // doit alors obligatoirement contenir le maillage.
+ const int * number, *numberIndex = 0;
+ string profilName;
+ vector<string> profilNameList;
+ vector<MED_EN::medGeometryElement> meshGeoType;
+ vector<int> meshNbOfElOfType;
+ vector<int> meshNbOfElOfTypeC;
+ vector<MED_EN::medGeometryElement> fileMeshGeoType;
+ vector<int> fileMeshNbOfElOfType;
+ vector<int> fileMeshNbOfElOfTypeC;
+ med_2_2::med_int fileHasMesh=0;
+
+ if (!onAll) {
+
+ number = mySupport->getNumber(MED_ALL_ELEMENTS);
+ numberIndex = mySupport->getNumberIndex();
+ profilNameList=mySupport->getProfilNames();
+
+ fileHasMesh = ( med_2_2::MEDdimLire(id, const_cast<char *>(meshName.c_str())) > 0);
+ MESH * meshPtr = mySupport->getMesh();
+
+ if (fileHasMesh)
+ getMeshGeometricTypeFromFile(id, meshName,
+ entityType,
+ fileMeshGeoType,fileMeshNbOfElOfType,fileMeshNbOfElOfTypeC);
+
+ if (meshPtr) {
+
+ getMeshGeometricTypeFromMESH( meshPtr, entityType,meshGeoType,
+ meshNbOfElOfType,
+ meshNbOfElOfTypeC);
+
+ if (fileHasMesh)
+ if ( ( fileMeshGeoType != meshGeoType ) || (fileMeshNbOfElOfTypeC != meshNbOfElOfTypeC) )
+ throw MEDEXCEPTION(LOCALIZED( STRING(LOC) <<": Error while getting mesh information from file for FIELD "<< fieldName
+ << " on entity " << MED_EN::entNames[entityType]
+ << " with (it,or) = ("
+ << MED_FIELD_DRIVER<T>::_ptrField->_iterationNumber << ","
+ << MED_FIELD_DRIVER<T>::_ptrField->_orderNumber << ")"
+ << " on mesh " << meshName
+ << " : geometric types or number of elements by type differs from MESH object !"
+ )
+ );
+
+ }
+
+ if ( !fileHasMesh && meshPtr==0 )
+ throw MEDEXCEPTION(LOCALIZED( STRING(LOC) <<": Error while getting mesh information for FIELD "<< fieldName
+ << " on entity " << MED_EN::entNames[entityType]
+ << " with (it,or) = ("
+ << MED_FIELD_DRIVER<T>::_ptrField->_iterationNumber << ","
+ << MED_FIELD_DRIVER<T>::_ptrField->_orderNumber << ")"
+ << " on mesh " << meshName
+ << " : SUPPORT must contain a valid MESH reference or file must contain the associated MESH."
+ )
+ );
+
+
+ if (fileHasMesh && !meshPtr) {
+ meshNbOfElOfTypeC = fileMeshNbOfElOfTypeC;
+ meshGeoType = fileMeshGeoType;
+ meshNbOfElOfType = fileMeshNbOfElOfType;
+ }
+ }
+
+ const MED_EN::medGeometryElement * types = mySupport->getTypes() ;
+ int numberOfTypes = mySupport->getNumberOfTypes() ;
+ int numberOfElForMED = -1;
+ const T * value = NULL;
+ int index = 1 ;
+ // on boucle sur tout les types pour ecrire les tableaux de valeur
+ for (int typeNo=0;typeNo<numberOfTypes;typeNo++) {
+
+ int numberOfElements = mySupport->getNumberOfElements(types[typeNo]) ;
+ //UP : prend en compte les profils, pas les points de Gauss
+
+ //value = MED_FIELD_DRIVER<T>::_ptrField->getRow(index) ;
+ // rem 1 : le getRow du Array est différent de celui du FIELD si le SUPPORT contient
+ // des profils (les indices des valeurs ne se suivent pas forcément)
+ // rem 2 : Afin de respecter la norme MEDFICHIER, les indices contenus dans les
+ // profils doivent être croissant
+ if (onAll) {
+ value = myField->getRow(index);
+ profilName=MED_NOPFL;
+ numberOfElForMED = numberOfElements;
+ } else {
+ value = myField->getRow(number[index-1]);
+ profilName = profilNameList[typeNo].substr(0,MED_TAILLE_NOM);
+ // Rem : Si le SUPPORT n'est pas onAll mais que pour un type géométrique donné le nom
+ // du profil associé est MED_NOPFL alors le profil n'est pas écrit dans le fichier MED.
+ // Car en MEDMEMOIRE si le champ repose sur des éléments de deux types géométriques
+ // différents et est défini sur tous les éléments d'un type géométrique
+ // mais pas de l'autre, il existe tout de même des profils sur les deux types géométriques.
+ // Ce n'est pas le cas en MEDFICHIER.
+ vector<int> profil(&number[index-1],&(number[index-1])+numberOfElements);
+
+ // Trouve l'index du type géométrique dans la liste des types géométriques du maillage
+ // correspondant au type géométrique du champ en cours de traitement
+ vector<MED_EN::medGeometryElement>::iterator meshTypeNoIt =
+ find(meshGeoType.begin(),meshGeoType.end(),types[typeNo]);
+ if ( meshTypeNoIt == meshGeoType.end() )
+ throw MEDEXCEPTION(LOCALIZED( STRING(LOC) <<": Can't find "<< MED_EN::geoNames[types[typeNo]]
+ << " on entity " << MED_EN::entNames[entityType]
+ << " in geometric type list of mesh " << meshName
+ )
+ );
+
+ int meshTypeNo = meshTypeNoIt - meshGeoType.begin();
+
+ if ( profilName == MED_NOPFL && profil.size() != meshNbOfElOfType[meshTypeNo] )
+ throw MEDEXCEPTION(LOCALIZED( STRING(LOC) <<": Error while creating profil for FIELD "<< fieldName
+ << " on entity " << MED_EN::entNames[entityType]
+ << " and geometric type " << MED_EN::geoNames[types[typeNo]] << " with (it,or) = ("
+ << MED_FIELD_DRIVER<T>::_ptrField->_iterationNumber << ","
+ << MED_FIELD_DRIVER<T>::_ptrField->_orderNumber << "), with profilName "
+ << profilName << " on mesh " << meshName
+ << " : There is no profileName but profilsize (" <<profil.size()
+ << ") differs from number of elements in associated MESH ("
+ << meshNbOfElOfType[meshTypeNo] << ")."
+ )
+ );
+
+ //REM : Ce n'est pas évident, mais lorsqu'il y a un profil, le nombre de valeurs
+ // que l'on indique à MEDchampEcr est le nombre de valeurs sans profil, d'où
+ // le nombre d'éléments du maillage sur le type géométrique courant.
+ numberOfElForMED = meshNbOfElOfType[meshTypeNo];
+
+ for (int ind=0;ind < numberOfElements;++ind) {
+// cout << "number["<<index-1<<"]="<<number[index-1]<<endl;
+// cout << "profil1["<<ind<<"]="<<profil[ind]<<endl;
+ profil[ind]-=meshNbOfElOfTypeC[meshTypeNo];
+// cout << "profil2["<<ind<<"]="<<profil[ind]<<endl;
+ }
+
+ if ( profil[numberOfElements-1] > numberOfElForMED )
+ throw MEDEXCEPTION(LOCALIZED( STRING(LOC) <<": Error while creating profil for FIELD "<< fieldName
+ << " on entity " << MED_EN::entNames[entityType]
+ << " and geometric type " << MED_EN::geoNames[types[typeNo]] << " with (it,or) = ("
+ << MED_FIELD_DRIVER<T>::_ptrField->_iterationNumber << ","
+ << MED_FIELD_DRIVER<T>::_ptrField->_orderNumber << "), with profilName "
+ << profilName << " on mesh " << meshName
+ << " : profil["<<numberOfElements-1<<"]=" << profil[numberOfElements-1]
+ << " must not be superior to field size without profil : "
+ << numberOfElForMED
+ )
+ );
+
+ if ( med_2_2::MEDMEMprofilEcr(id,
+ &profil[0],
+ numberOfElements,
+ const_cast<char *>(profilName.c_str())) < 0)
+
+ throw MEDEXCEPTION(LOCALIZED( STRING(LOC) <<": Error while writing "<< numberOfElements
+ << " values for MED profil "<< profilName
+ )
+ );
+ }
+
+
+ string locName=MED_NOGAUSS;
+ if (myField->getGaussPresence()) {
+// cout << endl << "Nombre de points de Gauss à l'écriture de " << fieldName
+// << " pour le type géométrique : " << MED_EN::geoNames[types[typeNo]]
+// << " : " << myField->getNumberOfGaussPoints(types[typeNo]) << endl;
+// cout << *mySupport << endl;
+
+ const GAUSS_LOCALIZATION_ * locPtr=0;
+ locMap::const_iterator it;
+ if ( ( it = gaussModel.find(types[typeNo])) != gaussModel.end() )
+ locPtr = (*it).second;
+ else
+ throw MEDEXCEPTION(LOCALIZED( STRING(LOC) <<": Error while creating Gauss Model for FIELD "<< fieldName
+ << " on entity " << MED_EN::entNames[entityType]
+ << " and geometric type " << MED_EN::geoNames[types[typeNo]] << " with (it,or) = ("
+ << MED_FIELD_DRIVER<T>::_ptrField->_iterationNumber << ","
+ << MED_FIELD_DRIVER<T>::_ptrField->_orderNumber << "), with profilName "
+ << profilName << " on mesh " << meshName
+ << " : Can't find a Gauss localisation model for this geometric type"
+ )
+ );
+
+ int ngauss = -1;
+ if ( locPtr->getInterlacingType() == MED_EN::MED_FULL_INTERLACE ) {
+ const GAUSS_LOCALIZATION<FullInterlace> & loc=*(static_cast<const GAUSS_LOCALIZATION<FullInterlace> * >(locPtr));
+ ngauss = loc.getNbGauss();
+ locName=loc.getName();
+ err=med_2_2::MEDMEMgaussEcr(id,
+ (med_2_2::med_geometrie_element) loc.getType(),
+ (med_2_2::med_float *) loc.getRefCoo().getPtr(),
+ med_2_2::MED_FULL_INTERLACE,
+ (med_2_2::med_int) ngauss,
+ (med_2_2::med_float *) loc.getGsCoo().getPtr(),
+ (med_2_2::med_float *) (&loc.getWeight()[0]),
+ const_cast<char *> (locName.c_str())
+ );
+ } else {
+ const GAUSS_LOCALIZATION<NoInterlace> & loc=*(static_cast<const GAUSS_LOCALIZATION<NoInterlace> * >(locPtr));
+ ngauss = loc.getNbGauss();
+ locName=loc.getName();
+ err=med_2_2::MEDMEMgaussEcr(id,
+ (med_2_2::med_geometrie_element) loc.getType(),
+ (med_2_2::med_float *) loc.getRefCoo().getPtr(),
+ med_2_2::MED_NO_INTERLACE,
+ (med_2_2::med_int) ngauss,
+ (med_2_2::med_float *) loc.getGsCoo().getPtr(),
+ (med_2_2::med_float *) (&loc.getWeight()[0]),
+ const_cast<char *> (locName.c_str())
);
- }
- Index += NumberOfElements ;
-
- }
- if ( MED_FIELD_DRIVER<T>::_ptrField->getInterlacingType() == MED_EN::MED_NO_INTERLACE ) delete myArray;
+ };
+
+ if ( err != 0 )
+ throw MEDEXCEPTION(LOCALIZED( STRING(LOC) <<": Error while writing Gauss Model for FIELD "<< fieldName
+ << " on entity " << MED_EN::entNames[entityType]
+ << " and geometric type " << MED_EN::geoNames[types[typeNo]]
+ )
+ );
+
+ //numberOfElForMED *= mySupport->getNumberOfGaussPoints(types[typeNo]); //Deplacer la méthode dans FIELD
+ numberOfElForMED *= ngauss;
+ }
+ MESSAGE("MED_FIELD_DRIVER22<T>::_medIdt : "<<id);
+ MESSAGE("meshName.c_str() : "<<meshName.c_str());
+ MESSAGE("MED_FIELD_DRIVER<T>::_ptrField->getName() : "<<MED_FIELD_DRIVER<T>::_ptrField->getName());
+ MESSAGE("MED_FIELD_DRIVER<T>::_fieldName : "<<MED_FIELD_DRIVER<T>::_fieldName);
+ MESSAGE("value : "<<value);
+ MESSAGE("numberOfElements : "<<numberOfElements);
+ MESSAGE("numberOfElForMED : "<<numberOfElForMED);
+ MESSAGE("entityType : "<<MED_EN::entNames[entityType]);
+ MESSAGE("types[i] : "<<MED_EN::geoNames[types[typeNo]]);
+ MESSAGE("NumberOfGaussPoint[i] : "<<myField->getNumberOfGaussPoints(types[typeNo]));
+ MESSAGE("MED_FIELD_DRIVER<T>::_ptrField->getIterationNumber() : "<<MED_FIELD_DRIVER<T>::_ptrField->getIterationNumber());
+ MESSAGE("MED_FIELD_DRIVER<T>::_ptrField->getTime() : "<<MED_FIELD_DRIVER<T>::_ptrField->getTime());
+ MESSAGE("MED_FIELD_DRIVER<T>::_ptrField->getOrderNumber() : "<<MED_FIELD_DRIVER<T>::_ptrField->getOrderNumber());
+
+ // Rem 1 : le nombre d'éléments passé à MEDchampEcr ne doit pas tenir compte de la taille
+ // des profils : c'est la taille du champ sans profil.
+ err=med_2_2::MEDchampEcr(id,
+ const_cast <char*> ( meshName.c_str()) ,
+ const_cast <char*> ( fieldName.c_str()),
+ (unsigned char*)value, med_2_2::MED_FULL_INTERLACE,
+ numberOfElForMED,
+ //UP : prend en compte le nombre de points de Gauss mais
+ // pas le nombre de composantes
+ const_cast <char*> ( locName.c_str()),
+ MED_ALL,
+ const_cast <char *> (profilName.c_str()), med_2_2::MED_COMPACT,
+ (med_2_2::med_entite_maillage)entityType,
+ (med_2_2::med_geometrie_element)types[typeNo],
+ MED_FIELD_DRIVER<T>::_ptrField->getIterationNumber(),
+ " ", // A FAIRE : IMPLEMENTER L'UNITE DU PAS DE TEMPS!
+ MED_FIELD_DRIVER<T>::_ptrField->getTime(),
+ MED_FIELD_DRIVER<T>::_ptrField->getOrderNumber()
+ );
+
+ if (err < MED_VALID ) {
+ if ( MED_FIELD_DRIVER<T>::_ptrField->getInterlacingType() == MED_EN::MED_NO_INTERLACE ) delete myField;
+ throw MEDEXCEPTION(LOCALIZED( STRING(LOC) <<": Error while writing "<< numberOfElements << " values for FIELD "<< fieldName
+ << " on entity " << MED_EN::entNames[entityType]
+ << " and geometric type " << MED_EN::geoNames[types[typeNo]]
+ << " with (it,or) = ("
+ << MED_FIELD_DRIVER<T>::_ptrField->_iterationNumber << ","
+ << MED_FIELD_DRIVER<T>::_ptrField->_orderNumber << "), with profilName "
+ << profilName << " on mesh " << meshName
+ )
+ );
}
-
+
+ index += numberOfElements ; //Ne doit pas prendre en compte le nombre de points de GAUSS
+ //ni les composantes.
+
+ }
+ if ( MED_FIELD_DRIVER<T>::_ptrField->getInterlacingType() == MED_EN::MED_NO_INTERLACE ) delete myField;
+
+
END_OF(LOC);
}
throw (MEDEXCEPTION)
{
BEGIN_OF("MED_FIELD_RDWR_DRIVER22::write(void)");
- MED_FIELD_WRONLY_DRIVER22<T>::write();
+ MED_FIELD_WRONLY_DRIVER22<T>::write();
END_OF("MED_FIELD_RDWR_DRIVER22::write(void)");
-}
+}
template <class T> void MED_FIELD_RDWR_DRIVER22<T>::read (void)
throw (MEDEXCEPTION)
class MED_MESH_DRIVER : public GENDRIVER
{
protected:
-
- MESH * _ptrMesh;
- string _meshName; // const ?
+
+ MESH * _ptrMesh;
+ mutable string _meshName;
int _meshNum; // INUTILE ?
/*!
Constructor.
*/
- MED_MESH_DRIVER(const string & fileName,
- MESH * ptrMesh,
+ MED_MESH_DRIVER(const string & fileName,
+ MESH * ptrMesh,
MED_EN::med_mode_acces accessMode) ;
/*!
Copy constructor.
{
//MESSAGE("MED_MESH_RDONLY_DRIVER22::~MED_MESH_RDONLY_DRIVER() has been destroyed");
}
-
+
GENDRIVER * MED_MESH_RDONLY_DRIVER22::copy(void) const
{
return new MED_MESH_RDONLY_DRIVER22(*this);
if (_status!=MED_OPENED)
throw MEDEXCEPTION(LOCALIZED(STRING(LOC) << "The _idt of file " << _fileName << " is : " << _medIdt << " (the file is not opened)." )) ;
+ if ( ( _meshName.empty() ) && ( _ptrMesh->_name.empty() ) )
+ throw MEDEXCEPTION(LOCALIZED(STRING(LOC)
+ <<" neither <meshName> is set in driver nor in object MESH.")) ;
+
+ // If _meshName is not set in driver, try to use _ptrMesh->_name
+ if ( ( _meshName.empty() ) && ( !_ptrMesh->_name.empty() ) )
+ _meshName=_ptrMesh->_name;
+
+ if ( _meshName.size() > MED_TAILLE_NOM )
+ throw MEDEXCEPTION(LOCALIZED(STRING(LOC)
+ <<" <meshName> size in object driver MESH is > MED_TAILLE_NOM ."));
+
+
_ptrMesh->_name = _meshName;
SCRUTE(_ptrMesh->getIsAGrid());
if (_status!=MED_OPENED)
throw MEDEXCEPTION(LOCALIZED(STRING(LOC) << "File "<<_fileName<<" is not open. Open it before write !"));
+ string fieldName;
+ if ( ( _meshName.empty() ) && ( _ptrMesh->_name.empty() ) )
+ throw MEDEXCEPTION(LOCALIZED(STRING(LOC)
+ <<" neither <meshName> is set in driver nor in object MESH.")) ;
+
+ // If _meshName is not set in driver, try to use _ptrmesh->_meshName
+ if ( ( _meshName.empty() ) && ( !_ptrMesh->_name.empty() ) )
+ _meshName=_ptrMesh->_name;
+
+ if ( _meshName.size() > MED_TAILLE_NOM )
+ throw MEDEXCEPTION(LOCALIZED(STRING(LOC)
+ <<" <meshName> size in object driver MESH is > MED_TAILLE_NOM ."));
+
+
if (_ptrMesh->getIsAGrid())
{
if ( writeGRID() != MED_VALID )
int numberOfGeometricType ;
medGeometryElement* geometricType ;
- int * numberOfGaussPoint ;
int * geometricTypeNumber ;
int * numberOfEntities ;
// MEDSKYLINEARRAY * mySkyLineArray = new MEDSKYLINEARRAY() ;
geometricType = new medGeometryElement[1] ;
const medGeometryElement * allType = getTypes(MED_FACE);
geometricType[0] = allType[0] ;
- numberOfGaussPoint = new int[1] ;
- numberOfGaussPoint[0] = 1 ;
geometricTypeNumber = new int[1] ; // not use, but initialized to nothing
geometricTypeNumber[0] = 0 ;
numberOfEntities = new int[1] ;
numberOfGeometricType = theType.size() ;
geometricType = new medGeometryElement[numberOfGeometricType] ;
//const medGeometryElement * allType = getTypes(MED_FACE); !! UNUSED VARIABLE !!
- numberOfGaussPoint = new int[numberOfGeometricType] ;
geometricTypeNumber = new int[numberOfGeometricType] ; // not use, but initialized to nothing
numberOfEntities = new int[numberOfGeometricType] ;
mySkyLineArrayIndex = new int[numberOfGeometricType+1] ;
map<medGeometryElement,int>::iterator theTypeIt ;
for (theTypeIt=theType.begin();theTypeIt!=theType.end();theTypeIt++) {
geometricType[index] = (*theTypeIt).first ;
- numberOfGaussPoint[index] = 1 ;
geometricTypeNumber[index] = 0 ;
numberOfEntities[index] = (*theTypeIt).second ;
mySkyLineArrayIndex[index+1]=mySkyLineArrayIndex[index]+numberOfEntities[index] ;
mySupport->setNumberOfGeometricType(numberOfGeometricType) ;
mySupport->setGeometricType(geometricType) ;
- mySupport->setNumberOfGaussPoint(numberOfGaussPoint) ;
// mySupport->setGeometricTypeNumber(geometricTypeNumber) ;
mySupport->setNumberOfElements(numberOfEntities) ;
mySupport->setTotalNumberOfElements(size) ;
delete[] numberOfEntities;
delete[] geometricTypeNumber;
- delete[] numberOfGaussPoint;
delete[] geometricType;
delete[] mySkyLineArrayIndex;
delete[] myListArray;
--- /dev/null
+#ifndef MEDMEM_SET_INTERLACING_TYPE
+#define MEDMEM_SET_INTERLACING_TYPE
+
+#include "MEDMEM_Tags.hxx"
+using namespace MEDMEM;
+
+namespace {
+
+ template < typename T > struct SET_INTERLACING_TYPE {
+ static const MED_EN::medModeSwitch _interlacingType = MED_EN::MED_UNDEFINED_INTERLACE; };
+ template < > struct SET_INTERLACING_TYPE<FullInterlace>{
+ static const MED_EN::medModeSwitch _interlacingType = MED_EN::MED_FULL_INTERLACE; };
+ template < > struct SET_INTERLACING_TYPE<NoInterlace> {
+ static const MED_EN::medModeSwitch _interlacingType = MED_EN::MED_NO_INTERLACE; };
+
+}
+#endif
}
}
+ostream& MEDMEM::operator<<(ostream &os, const MEDSKYLINEARRAY &sky) {
+ os << "_count : " << sky._count << " ,_length : " << sky._length;
+ for (int i = 0; i < sky._count ; i++) {
+ os << endl << "Values of type n°" << i+1 << " (index["<<i<<"]="<< sky._index[i]<<") :" << endl;
+ for (int j=sky._index[i]-1;j < sky._index[i+1]-1;j++)
+ os << sky._value[j] << " " ;
+ }
+ return os;
+}
+
// void MEDSKYLINEARRAY::setMEDSKYLINEARRAY( const int count , const int length, int* index , int* value )
// {
// MESSAGE("void MEDSKYLINEARRAY::setMEDSKYLINEARRAY(count, length, index, value)");
int _count ;
int _length ;
PointerOf <int> _index ; // array of size _count+1 : _index[0]=1 and
- // _index[_count]=length+1
+ // _index[_count]=length+1
PointerOf <int> _value ; // array of size _length
public :
+ // Attention, avec ce constructeur, il n'est possible de remplir le MEDSKYLINEARRAY
MEDSKYLINEARRAY();
- ~MEDSKYLINEARRAY();
+
+ // Constructeur par recopie
MEDSKYLINEARRAY( const MEDSKYLINEARRAY &myArray );
+
+ // Avec ce constructeur la mémoire pour le tableau de valeur et le
+ // tableau d'index est réservée. Il suffit d'effectuer les séquences
+ // d'appels suivantes pour initialiser le MEDSKYLINEARRAY
+ // 1) setIndex(index) puis <count> fois setI(i,&listValeurN°I) avec i dans 1..count
+ // rem : listValeurN°I est dupliquée
+ // 2) appeler <length> fois setIJ(i,j,valeur) avec i dans 1..count et avec j dans 1..count
MEDSKYLINEARRAY( const int count, const int length );
+
+ // Avec ce constructeur le MEDSKYLINEARRAY est complètement initialisé
+ // Si shallowCopy=false (par défaut) les tableaux d'index et de valeurs
+ // sont dupliqués
+ // Sinon le MEDSKYLINEARRAY prend directement les pointeurs et en devient
+ // propriétaire
MEDSKYLINEARRAY( const int count, const int length,
const int* index, const int* value, bool shallowCopy=false );
+ ~MEDSKYLINEARRAY();
//void setMEDSKYLINEARRAY( const int count, const int length, int* index , int* value ) ;
inline int getNumberOf() const;
inline void setIJ(int i, int j, int value) throw (MEDEXCEPTION) ;
inline void setIndexValue(int i, int value) throw (MEDEXCEPTION) ;
+ friend ostream& operator<<(ostream &os, const MEDSKYLINEARRAY &sky);
};
// ---------------------------------------
if (m._geometricType)
_geometricType.set(_numberOfGeometricType,m._geometricType);
- if (m._numberOfGaussPoint)
- _numberOfGaussPoint.set(_numberOfGeometricType,m._numberOfGaussPoint);
-
_isOnAllElts = m._isOnAllElts;
if (m._numberOfElements)
_numberOfGeometricType = m._numberOfGeometricType;
if (m._geometricType)
_geometricType.set(_numberOfGeometricType,m._geometricType);
- if (m._numberOfGaussPoint)
- _numberOfGaussPoint.set(_numberOfGeometricType,m._numberOfGaussPoint);
_isOnAllElts = m._isOnAllElts;
if (m._numberOfElements)
_numberOfElements.set(_numberOfGeometricType,m._numberOfElements);
{
os << "Name : "<< my.getName() << endl ;
os << "Description : "<< my.getDescription() << endl ;
- os << "Mesh name : ";
+ os << "Mesh ptr : ";
if (my.getMesh() == NULL)
- os << "ERROR : Mesh not defined !" << endl ;
+ os << " Mesh not defined." << endl ;
else
- os << my._mesh->getName() << endl ;
- os << "Entity : "<< my._entity << endl;
+ os << " Mesh defined." << endl;
+ os << "MeshName : ";
+ os << my.getMeshName() << endl ;
+ os << "Entity : "<<MED_EN::entNames[my._entity] << endl;
os << "Entity list : "<< endl;
- if (!(my._isOnAllElts)) {
- int numberoftypes = my._numberOfGeometricType ;
- os << "NumberOfTypes : "<<numberoftypes<<endl;
- PointerOf<medGeometryElement> types = my._geometricType;
- for (int j=0;j<numberoftypes;j++) {
- int numberOfElements = my._numberOfElements[j];
- os << " * Type "<<types[j]<<" : there is(are) "<<numberOfElements<<" element(s) :" << endl;
-// const int * number = my.getNumber(types[j]);
-// SCRUTE(number);
-// os << " --> ";
-// for (int k=0; k<numberOfElements;k++)
-// os << number[k] << " ";
-// os << endl ;
- }
- } else
- os << "Is on all entities !"<< endl;
-
+ if ( my._isOnAllElts )
+ os << "Is on all entities."<< endl;
+ else {
+ os << "Is not on all entities. "<< endl;
+ os << *my.getNumber(MED_ALL_ELEMENTS);
+ }
+ int numberoftypes = my._numberOfGeometricType ;
+ os << "NumberOfTypes : "<<numberoftypes<<endl;
+ PointerOf<medGeometryElement> types = my._geometricType;
+ for (int j=0;j<numberoftypes;j++) {
+ int numberOfElements = my._numberOfElements[j];
+ os << " On Type "<<MED_EN::geoNames[types[j]]
+ <<" : there is(are) "<<numberOfElements<<" element(s) and " <<endl;
+ }
return os ;
}
_geometricType.set(1);
_geometricType[0]=MED_NONE;
_numberOfElements.set(1);
- _numberOfElements[0]=_mesh->getNumberOfNodes();
+ _numberOfElements[0]=_mesh->getNumberOfNodes(); // Vérifier le pointeur !
_totalNumberOfElements=_numberOfElements[0];
- _numberOfGaussPoint.set(1) ;
- _numberOfGaussPoint[0]=1;
}
else
{ // we duplicate information from _mesh
SCRUTE(_numberOfGeometricType);
_geometricType.set(_numberOfGeometricType,_mesh->getTypesWithPoly(_entity) );
_numberOfElements.set(_numberOfGeometricType);
- _numberOfGaussPoint.set(_numberOfGeometricType);
_totalNumberOfElements=0;
for (int i=0;i<_numberOfGeometricType;i++)
{
_numberOfElements[i]=_mesh->getNumberOfElementsWithPoly(_entity,_geometricType[i]) ;
_totalNumberOfElements+=_numberOfElements[i];
- _numberOfGaussPoint[i]=1 ;
}
}
SCRUTE(_name);
SCRUTE(_numberOfGeometricType);
- SCRUTE(_numberOfGaussPoint);
}
END_OF(LOC);
};
//-------------------
{
const char * LOC="getValIndFromGlobalNumber(const int number) : ";
- BEGIN_OF(LOC);
+ //BEGIN_OF(LOC);
if (_isOnAllElts) return number;
else
iThis++;
+ //if (!_isOnAllElts)
+ cout << "----Contenu du skyline : ---------------------" << *_number << endl;
+
if(!found)
throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"Can't find the global number |"
<< number << "| in Support |"
<< getName() << "|" ));
-
+
// It should never arrive here !!
return 0;
- END_OF(LOC);
+ //END_OF(LOC);
}
/*!
_geometricType.set(NumberOfGeometricType);
_numberOfElements.set(NumberOfGeometricType);
_totalNumberOfElements = TotalNumberOfElements;
- _numberOfGaussPoint.set(NumberOfGeometricType);
int * index = new int[_numberOfGeometricType+1];
index[0]=1;
throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"unhomogeneous geometric types (dimension) !"));
_geometricType[i] = GeometricType[i] ;
_numberOfElements[i] = NumberOfElements[i] ;
- _numberOfGaussPoint[i] = 1 ;
index[i+1] = index[i]+NumberOfElements[i] ;
}
};
+/*!
+ This function allows the user to set a support not on all entities Entity,
+ it should be used after an initialisation of :
+ SUPPORT(MESH* Mesh, string Name="", medEntityMesh Entity=MED_CELL) and
+ after calling at least setGeometricType and perharps setEntity.
+ It allocates and initialises all the attributs of the class SUPPORT but
+ doesn't set a description, a SUPPORT name, a meshName and an associated MESH.
+ */
+
+//-------------------
+void SUPPORT::setpartial(MEDSKYLINEARRAY * number, bool shallowCopy) throw (MEDEXCEPTION)
+//-------------------
+{
+ const char * LOC = "SUPPORT::setpartial(MEDSKYLINEARRAY * number) : " ;
+ BEGIN_OF(LOC) ;
+
+ if ( ! _geometricType )
+ throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"SUPPORT must contains"
+ << " a geometric type list" )) ;
+
+ _numberOfGeometricType = number->getNumberOf();
+
+ _numberOfElements.set(_numberOfGeometricType);
+
+ for (int i=0; i< _numberOfGeometricType; i++)
+ _numberOfElements[i] = number->getNumberOfI(i+1);
+
+ _totalNumberOfElements = number->getLength();
+
+ _isOnAllElts = false ;
+
+ if (_number!=NULL) delete _number ;
+
+ if ( shallowCopy )
+ _number = number;
+ else
+ _number = new MEDSKYLINEARRAY(*number);
+
+ // cout << *_number << endl;
+
+ END_OF(LOC);
+};
+
+void SUPPORT::setProfilNames(vector<string> profilNames) throw (MEDEXCEPTION){
+
+ const char * LOC = "SUPPORT::setProfilNames(vector<string> profilNames) : " ;
+ BEGIN_OF(LOC) ;
+
+ if ( _isOnAllElts )
+ throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"SUPPORT shouldn't be on all elements"
+ << " while setting profil name list" )) ;
+
+ if ( ! _geometricType || _numberOfGeometricType==0 )
+ throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"SUPPORT must contains"
+ << " a least one geometric type" )) ;
+
+ if ( ! _number )
+ throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"SUPPORT must contains"
+ << " a profil number list before setting"
+ << " the associated profil name list" )) ;
+
+ if ( ( profilNames.size() != _number->getNumberOf() ) &&
+ ( profilNames.size() !=_numberOfGeometricType ) ) {
+ throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"The profil name list size : "<< profilNames.size()
+ << " must be equal to the number of geometric type : "
+ << _numberOfGeometricType << " (_number->getNumberOf() : "
+ << _number->getNumberOf() << " )"
+ )) ;
+
+ }
+
+ _profilNames = profilNames;
+
+ END_OF(LOC);
+
+};
+
+vector<string> SUPPORT::getProfilNames() const throw (MEDEXCEPTION)
+{
+ return _profilNames;
+};
+
+
/*!
This method gets the boundary elements of the mesh. The support has to be
build using the constructor SUPPORT(MESH *,string, medEntityMesh) or
int numberOfGeometricType ;
medGeometryElement* geometricType ;
- int * numberOfGaussPoint ;
int * geometricTypeNumber ;
int * numberOfElements ;
//MEDSKYLINEARRAY * mySkyLineArray = new MEDSKYLINEARRAY() ;
geometricType = new medGeometryElement[1] ;
const medGeometryElement * allType = _mesh->getTypes(_entity);
geometricType[0] = allType[0] ;
- numberOfGaussPoint = new int[1] ;
- numberOfGaussPoint[0] = 1 ;
geometricTypeNumber = new int[1] ; // not use, but initialized to nothing
geometricTypeNumber[0] = 0 ;
numberOfElements = new int[1] ;
numberOfGeometricType = theType.size() ;
geometricType = new medGeometryElement[numberOfGeometricType] ;
//const medGeometryElement * allType = _mesh->getTypes(_entity); !! UNUSED VARIABLE !!
- numberOfGaussPoint = new int[numberOfGeometricType] ;
geometricTypeNumber = new int[numberOfGeometricType] ; // not use, but initialized to nothing
numberOfElements = new int[numberOfGeometricType] ;
mySkyLineArrayIndex = new int[numberOfGeometricType+1] ;
map<medGeometryElement,int>::iterator theTypeIt ;
for (theTypeIt=theType.begin();theTypeIt!=theType.end();theTypeIt++) {
geometricType[index] = (*theTypeIt).first ;
- numberOfGaussPoint[index] = 1 ;
- geometricTypeNumber[index] = 0 ;
+ geometricTypeNumber[index] = 0 ;
numberOfElements[index] = (*theTypeIt).second ;
mySkyLineArrayIndex[index+1]=mySkyLineArrayIndex[index]+numberOfElements[index] ;
index++ ;
setNumberOfGeometricType(numberOfGeometricType) ;
// setGeometricType(geometricType) ;
- // setNumberOfGaussPoint(numberOfGaussPoint) ;
- for (int i=0;i<numberOfGeometricType;i++)
+ for (int i=0;i<numberOfGeometricType;i++)
{
- _numberOfGaussPoint[i] = numberOfGaussPoint[i];
_geometricType[i] = geometricType[i];
}
delete[] numberOfElements;
delete[] geometricTypeNumber;
- delete[] numberOfGaussPoint;
delete[] geometricType;
delete[] mySkyLineArrayIndex;
delete[] myListArray;
{
operatorReturn = operatorReturn &&
(_geometricType[i] == support._geometricType[i]) &&
- (_numberOfElements[i] == support._numberOfElements[i]) &&
- (_numberOfGaussPoint[i] == support._numberOfGaussPoint[i]);
+ (_numberOfElements[i] == support._numberOfElements[i]);
if (operatorReturn)
{
for (int i=0; i<_numberOfGeometricType && operatorReturn; i++)
{
operatorReturn = (_geometricType[i] == support._geometricType[i]) &&
- (_numberOfElements[i] == support._numberOfElements[i]) &&
- (_numberOfGaussPoint[i] == support._numberOfGaussPoint[i]);
+ (_numberOfElements[i] == support._numberOfElements[i]);
if (operatorReturn)
{
for (int j=0; j<_numberOfElements[i]; j++)
int numberOfGeometricType=1;
medGeometryElement* geometricType=new medGeometryElement[1];
geometricType[0]=MED_NONE;
- int *numberOfGaussPoint=new int[1];
- numberOfGaussPoint[0]=1;
int *numberOfElements=new int[1];
numberOfElements[0]=size;
int *mySkyLineArrayIndex=new int[2];
MEDSKYLINEARRAY * mySkyLineArray = new MEDSKYLINEARRAY(1,numberOfElements[0],mySkyLineArrayIndex,tab,true);
setNumberOfGeometricType(numberOfGeometricType);
setGeometricType(geometricType);
- setNumberOfGaussPoint(numberOfGaussPoint);
setNumberOfElements(numberOfElements);
setTotalNumberOfElements(numberOfElements[0]);
setNumber(mySkyLineArray);
delete[] numberOfElements;
- delete[] numberOfGaussPoint;
delete[] geometricType;
}
myListArray[id++]=(*myElementsListIt) ;
int numberOfGeometricType ;
medGeometryElement* geometricType ;
- int * numberOfGaussPoint ;
int * numberOfElements ;
int * mySkyLineArrayIndex ;
geometricType = new medGeometryElement[1] ;
medGeometryElement * allType = _mesh->getTypesWithPoly(_entity);
geometricType[0] = allType[0] ;
- numberOfGaussPoint = new int[1] ;
- numberOfGaussPoint[0] = 1 ;
numberOfElements = new int[1] ;
numberOfElements[0] = size ;
mySkyLineArrayIndex = new int[2] ;
}
numberOfGeometricType = theType.size() ;
geometricType = new medGeometryElement[numberOfGeometricType] ;
- numberOfGaussPoint = new int[numberOfGeometricType] ;
numberOfElements = new int[numberOfGeometricType] ;
mySkyLineArrayIndex = new int[numberOfGeometricType+1] ;
int index = 0 ;
map<medGeometryElement,int>::iterator theTypeIt ;
for (theTypeIt=theType.begin();theTypeIt!=theType.end();theTypeIt++) {
geometricType[index] = (*theTypeIt).first ;
- numberOfGaussPoint[index] = 1 ;
numberOfElements[index] = (*theTypeIt).second ;
mySkyLineArrayIndex[index+1]=mySkyLineArrayIndex[index]+numberOfElements[index] ;
index++ ;
MEDSKYLINEARRAY * mySkyLineArray = new MEDSKYLINEARRAY(numberOfGeometricType,size,mySkyLineArrayIndex,myListArray,true) ;
setNumberOfGeometricType(numberOfGeometricType) ;
setGeometricType(geometricType) ;
- setNumberOfGaussPoint(numberOfGaussPoint) ;
- setNumberOfElements(numberOfElements) ;
+ setNumberOfElements(numberOfElements) ;
setTotalNumberOfElements(size) ;
setNumber(mySkyLineArray) ;
delete[] numberOfElements;
- delete[] numberOfGaussPoint;
delete[] geometricType;
}
/*!
\if developper
- Array of size _numberOfGeometricType which contains
- for each type the number of gauss point
- (not yet implemented).
- \endif
- */
- mutable PointerOf<int> _numberOfGaussPoint ;
-
- /*!
- \if developper
- If true, we consider all entities of type _entity.
+ If true, we consider all entities of type _entity
+ defined in the associated mesh
\endif
*/
bool _isOnAllElts;
*/
mutable MEDSKYLINEARRAY * _number;
+ /*!
+ \if developper
+ Array of size <_numberOfGeometricType> wich contain the profil name of
+ entities of each geometric type.\n
+ Defined only if _isOnAllElts is false.
+ If it exist an entities list on a geometric type in _number but there is no profil name associated
+ ( MED_NOPFL ) the MED driver will consider and verify this entities list as being all the
+ entities available on the associated mesh for this geometric type.
+ \endif
+ */
+
+ vector< string > _profilNames;
+
public:
+
SUPPORT();
SUPPORT(MESH* Mesh, string Name="", MED_EN::medEntityMesh Entity=MED_EN::MED_CELL);
SUPPORT(const SUPPORT & m);
inline void setEntity(MED_EN::medEntityMesh Entity);
inline void setNumberOfGeometricType(int NumberOfGeometricType);
inline void setGeometricType(const MED_EN::medGeometryElement *GeometricType);
- inline void setNumberOfGaussPoint(const int *NumberOfGaussPoint);
inline void setNumberOfElements(const int *NumberOfElements);
inline void setTotalNumberOfElements(int TotalNumberOfElements);
inline void setNumber(MEDSKYLINEARRAY * Number);
inline bool isOnAllElements() const;
inline int getNumberOfTypes() const;
inline const MED_EN::medGeometryElement* getTypes() const ;
- inline const int * getNumberOfGaussPoint() const throw (MEDEXCEPTION);
- inline int getNumberOfGaussPoint(MED_EN::medGeometryElement geomElement) const throw (MEDEXCEPTION);
inline int getNumberOfElements(MED_EN::medGeometryElement GeometricType) const throw (MEDEXCEPTION);
inline const int * getNumberOfElements() const throw (MEDEXCEPTION);
- // rename getnumber -> getGlobalNumberSky()
virtual inline MEDSKYLINEARRAY * getnumber() const throw (MEDEXCEPTION);
- // rename getNumber -> getGlobalNumberPtr()
virtual inline const int * getNumber(MED_EN::medGeometryElement GeometricType) const throw (MEDEXCEPTION);
- // rename in getGlobalNumberInd()
virtual inline const int * getNumberIndex() const throw (MEDEXCEPTION);
virtual int getValIndFromGlobalNumber(const int number) const throw (MEDEXCEPTION);
void blending(SUPPORT * mySupport) throw (MEDEXCEPTION) ;
+ // Les numéros d'entités dans les profils doivent être croissant
+ // pour respecter la norme MED
void setpartial(string Description, int NumberOfGeometricType,
int TotalNumberOfEntity, MED_EN::medGeometryElement *GeometricType,
int *NumberOfEntity, int *NumberValue);
+ void setpartial(MEDSKYLINEARRAY * number, bool shallowCopy=false) throw (MEDEXCEPTION);
+
+ // Si les noms de profils ne sont pas positionnés, les profils ne seront
+ // pas écrits par MEDFICHIER.
+ void setProfilNames(vector<string> profilNames) throw (MEDEXCEPTION);
+ //string getProfilName(const MED_EN::medGeometryElement GeometricType) const throw (MEDEXCEPTION);
+ vector<string> getProfilNames() const throw (MEDEXCEPTION);
+
void getBoundaryElements() throw (MEDEXCEPTION);
void changeElementsNbs(MED_EN::medEntityMesh entity, const int *renumberingFromOldToNew, int limitNbClassicPoly, const int *renumberingFromOldToNewPoly=0);
void intersecting(SUPPORT * mySupport) throw (MEDEXCEPTION) ;
This method returns the number of all elements of the type GeometricType.
If isOnAllElements is false, it returns the number of elements in the
- support else it returns number of elements in the whole mesh.
+ support else it returns number of elements in the mesh.
Example : number of MED_TRIA3 or MED_ALL_ELEMENTS elements
in entity of support.
Note : If SUPPORT is defined on MED_NODE, use MED_ALL_ELEMENTS as
medGeometryElement GeometricType and it will returns the number
- of nodes in the support (or in the whole mesh).
+ of nodes in the support (or in the mesh).
*/
//-----------------------------------------------------------------------------
inline int SUPPORT::getNumberOfElements(MED_EN::medGeometryElement GeometricType) const
return _number->getIndex() ;
}
-/*! A DOCUMENTER */
-//-------------------------------------------------
-inline const int * SUPPORT::getNumberOfGaussPoint() const
- throw (MEDEXCEPTION)
-//-------------------------------------------------
-{
- SCRUTE(_name);
- SCRUTE(_numberOfGeometricType);
- SCRUTE(_numberOfGaussPoint);
-
- if (_numberOfGaussPoint!=NULL)
- return _numberOfGaussPoint ;
- else
- throw MEDEXCEPTION("Support::getNumberOfGaussPoint : Not defined !") ;
-}
-
-/*!
- Returns number of Gauss points for this medGeometryElement.
-
- Note :
- - Not defined if SUPPORT is on MED_NODE.
- - Not defined for MED_ALL_ELEMENTS medGeometryElement type.
-*/
-//-----------------------------------------------------------------------------
-inline int SUPPORT::getNumberOfGaussPoint(MED_EN::medGeometryElement geomElement) const
- throw (MEDEXCEPTION)
-//-----------------------------------------------------------------------------
-{
- if (_numberOfGaussPoint!=NULL) {
- for (int i=0;i<_numberOfGeometricType;i++)
- if (_geometricType[i]==geomElement)
- return _numberOfGaussPoint[i] ;
- throw MEDEXCEPTION("Support::getGlobalNumber : GeometricType not found !") ;
- } else
- return 1;
-}
/*! set the attribute _name to Name */
//--------------------------------------
_meshName=meshName;
}
-/*! set the attribute _isOnAllElts to All */
+/*! set the attribute _isOnAllElts to All
+ Even if _isonAllElts is true, geometric types definning the FIELD's SUPPORT
+ must be read from the SUPPORT not from the associated MESH (the geometric
+ types definning the FIELD's SUPPORT may be a subset of the geometric types
+ defined in the MESH even if for each SUPPORT geometric type all MESH entities
+ are used).
+*/
//------------------------------------------
inline void SUPPORT::setAll(bool All)
//------------------------------------------
_geometricType.set(0);
_numberOfElements.set(0);
- _numberOfGaussPoint.set(0) ;
}
/*! set the attribute _geometricType to geometricType */
_geometricType[i] = GeometricType[i];
}
-/*! set the attribute _numberOfGaussPoint to NumberOfGaussPoint */
-//-----------------------------------------------------------------
-inline void SUPPORT::setNumberOfGaussPoint(const int *NumberOfGaussPoint)
-//-----------------------------------------------------------------
-{
- if (NULL == _numberOfGaussPoint)
- _numberOfGaussPoint.set(_numberOfGeometricType);
- for (int i=0;i<_numberOfGeometricType;i++)
- _numberOfGaussPoint[i] = NumberOfGaussPoint[i];
-}
/*!
Set the attribute _numberOfElements to NumberOfElements and
{
CHECKING_POLICY::checkMoreThanZero("MEDMEM_Array",nbelem);
CHECKING_POLICY::checkMoreThanZero("MEDMEM_Array",dim);
- _array.set(INTERLACING_POLICY::_arraySize);
+ _array.set(InterlacingPolicy::_arraySize);
};
// Le mot clé inline permettra d'instancier le constructeur uniquement
_array.set((const ElementType*)values);
else // Cas par défaut
- _array.set(INTERLACING_POLICY::_arraySize,values);
+ _array.set(InterlacingPolicy::_arraySize,values);
}
CHECKING_POLICY::checkMoreThanZero("MEDMEM_Array",nbelem);
CHECKING_POLICY::checkMoreThanZero("MEDMEM_Array",dim);
CHECKING_POLICY::checkMoreThanZero("MEDMEM_Array",nbtypegeo);
- _array.set(INTERLACING_POLICY::_arraySize);
+ _array.set(InterlacingPolicy::_arraySize);
};
_array.set((const ElementType*)values);
else
- _array.set(INTERLACING_POLICY::_arraySize,values);
+ _array.set(InterlacingPolicy::_arraySize,values);
};
if (shallowCopy)
this->_array.set(array._array); // Le propriétaire reste le ARRAY initial
else
- this->_array.set(INTERLACING_POLICY::_arraySize,array._array);
+ this->_array.set(InterlacingPolicy::_arraySize,array._array);
}
InterlacingPolicy::operator=(array); //Appel des classes de base ?
this->_array.set(array._array); // Le propriétaire reste le ARRAY initial
- // verifier l'appel des opérateurs de la policy
return *this;
}
_array.set((const ElementType*)values);
else
- _array.set(INTERLACING_POLICY::_arraySize,values);
+ _array.set(InterlacingPolicy::_arraySize,values);
}
inline const ElementType * getRow(int i) const {
- checkInInclusiveRange("MEDMEM_Array",1,INTERLACING_POLICY::_nbelem,i);
+ checkInInclusiveRange("MEDMEM_Array",1,InterlacingPolicy::_nbelem,i);
// Empêche l'utilisation de getRow en mode MED_NO_INTERLACE
// Ne devrait pas dépendre de la politique check
checkEquality("MEDMEM_Array (Interlace test)",
MED_EN::MED_NO_INTERLACE,
- INTERLACING_POLICY::_interlacing );
- return &(_array[ INTERLACING_POLICY::getIndex(i,1) ]);
+ InterlacingPolicy::_interlacing );
+ return &(_array[ InterlacingPolicy::getIndex(i,1) ]);
}
void setRow(int i,const ElementType * const value) {
- checkInInclusiveRange("MEDMEM_Array",1,INTERLACING_POLICY::_nbelem,i);
+ checkInInclusiveRange("MEDMEM_Array",1,InterlacingPolicy::_nbelem,i);
// setRow fonctionne
// dans les deux modes d'entrelacement.
- for (int j =1; j <= INTERLACING_POLICY::getDim(); j++)
- for (int k = 1 ; k <= INTERLACING_POLICY::getNbGauss(i); k++)
- _array[INTERLACING_POLICY::getIndex(i,j,k)] = value[INTERLACING_POLICY::getIndex(1,j,k)];
+ for (int j =1; j <= InterlacingPolicy::getDim(); j++)
+ for (int k = 1 ; k <= InterlacingPolicy::getNbGauss(i); k++)
+ _array[InterlacingPolicy::getIndex(i,j,k)] = value[InterlacingPolicy::getIndex(1,j,k)];
}
inline const ElementType * getColumn(int j) const {
- checkInInclusiveRange("MEDMEM_Array",1,INTERLACING_POLICY::_dim,j);
+ checkInInclusiveRange("MEDMEM_Array",1,InterlacingPolicy::_dim,j);
checkEquality("MEDMEM_Array (Interlace test)",
- MED_EN::MED_FULL_INTERLACE, INTERLACING_POLICY::_interlacing );
- return &(_array[ INTERLACING_POLICY::getIndex(1,j) ]);
+ MED_EN::MED_FULL_INTERLACE, InterlacingPolicy::_interlacing );
+ return &(_array[ InterlacingPolicy::getIndex(1,j) ]);
}
void setColumn(int j, const ElementType * const value) {
- checkInInclusiveRange("MEDMEM_Array",1,INTERLACING_POLICY::_dim,j);
+ checkInInclusiveRange("MEDMEM_Array",1,InterlacingPolicy::_dim,j);
// setColumn fonctionne
// dans les deux modes d'entrelacement.
- for (int i=1; i <= INTERLACING_POLICY::getNbElem(); i++)
- for (int k = 1 ; k <= INTERLACING_POLICY::getNbGauss(i); k++)
- _array[INTERLACING_POLICY::getIndex(i,j,k)] = value[INTERLACING_POLICY::getIndex(i,1,k)];
+ for (int i=1; i <= InterlacingPolicy::getNbElem(); i++)
+ for (int k = 1 ; k <= InterlacingPolicy::getNbGauss(i); k++)
+ _array[InterlacingPolicy::getIndex(i,j,k)] = value[InterlacingPolicy::getIndex(i,1,k)];
}
inline const ElementType & getIJ(int i, int j) const {
- checkInInclusiveRange("MEDMEM_Array",1,INTERLACING_POLICY::_nbelem,i);
- checkInInclusiveRange("MEDMEM_Array",1,INTERLACING_POLICY::_dim,j);
- return _array[ INTERLACING_POLICY::getIndex(i,j) ];
+ checkInInclusiveRange("MEDMEM_Array",1,InterlacingPolicy::_nbelem,i);
+ checkInInclusiveRange("MEDMEM_Array",1,InterlacingPolicy::_dim,j);
+ return _array[ InterlacingPolicy::getIndex(i,j) ];
}
inline const ElementType & getIJK(int i, int j, int k ) const {
- checkInInclusiveRange("MEDMEM_Array",1,INTERLACING_POLICY::_nbelem,i);
- checkInInclusiveRange("MEDMEM_Array",1,INTERLACING_POLICY::_dim,j);
- checkInInclusiveRange("MEDMEM_Array",1,INTERLACING_POLICY::getNbGauss(i),k);
+ checkInInclusiveRange("MEDMEM_Array",1,InterlacingPolicy::_nbelem,i);
+ checkInInclusiveRange("MEDMEM_Array",1,InterlacingPolicy::_dim,j);
+ checkInInclusiveRange("MEDMEM_Array",1,InterlacingPolicy::getNbGauss(i),k);
- return _array[ INTERLACING_POLICY::getIndex(i,j,k) ];
+ return _array[ InterlacingPolicy::getIndex(i,j,k) ];
};
inline void setIJ(int i, int j, const ElementType & value) { //autre signature avec
- checkInInclusiveRange("MEDMEM_Array",1,INTERLACING_POLICY::_nbelem,i);
- checkInInclusiveRange("MEDMEM_Array",1,INTERLACING_POLICY::_dim,j);
+ checkInInclusiveRange("MEDMEM_Array",1,InterlacingPolicy::_nbelem,i);
+ checkInInclusiveRange("MEDMEM_Array",1,InterlacingPolicy::_dim,j);
- _array[ INTERLACING_POLICY::getIndex(i,j) ] = value; // retour ElementType & ?
+ _array[ InterlacingPolicy::getIndex(i,j) ] = value; // retour ElementType & ?
};
inline void setIJK(int i, int j, int k, const ElementType & value) { //autre signature avec
- checkInInclusiveRange("MEDMEM_Array",1,INTERLACING_POLICY::_nbelem,i);
- checkInInclusiveRange("MEDMEM_Array",1,INTERLACING_POLICY::_dim,j);
- checkInInclusiveRange("MEDMEM_Array",1,INTERLACING_POLICY::getNbGauss(i),k);
+ checkInInclusiveRange("MEDMEM_Array",1,InterlacingPolicy::_nbelem,i);
+ checkInInclusiveRange("MEDMEM_Array",1,InterlacingPolicy::_dim,j);
+ checkInInclusiveRange("MEDMEM_Array",1,InterlacingPolicy::getNbGauss(i),k);
- _array[ INTERLACING_POLICY::getIndex(i,j,k) ] = value; // retour ElementType & ?
+ _array[ InterlacingPolicy::getIndex(i,j,k) ] = value; // retour ElementType & ?
};
+ bool operator == (const MEDMEM_Array & array ) const {
+
+ if ( this == &array ) return true;
+
+ int size = array.getArraySize();
+ if ( size != getArraySize() ) return false;
+
+ ARRAY_ELEMENT_TYPE * arrayPtr =
+ const_cast<MEDMEM_Array &>(array).getPtr();
+ for (int i=0; i < size; ++i)
+ if (_array[i] != arrayPtr[i]) return false;
+
+ return true;
+ }
+
+ friend ostream & operator<<(ostream & os, const MEDMEM_Array & array) {
+
+ for (int i=1;i<=array.getNbElem();++i) {
+ for (int j=1; j<=array.getDim();++j)
+ for (int k=1;k<=array.getNbGauss(i);++k)
+ os << "Value [" << i << "," << j << "," << k << "] = " << array.getIJK(i,j,k) << ", ";
+ os << endl;
+ }
+ return os;
+ }
private:
MEDMEM_Tags.hxx \
MEDMEM_FieldConvert.hxx \
MEDMEM_ArrayConvert.hxx \
-MEDMEM_FieldForward.hxx
+MEDMEM_FieldForward.hxx \
+MEDMEM_GaussLocalization.hxx \
+MEDMEM_MEDMEMgaussEcr.hxx \
+MEDMEM_MEDMEMprofilEcr.hxx \
+MEDMEM_MEDMEMchampLire.hxx \
+MEDMEM_SetInterlacingType.hxx
# Libraries targets
MEDMEM_medimport_src.cxx \
MEDMEM_PolyhedronArray.cxx \
MEDMEM_MedMedDriver22.cxx \
-MEDMEM_MedMeshDriver22.cxx
+MEDMEM_MedMeshDriver22.cxx \
+MEDMEM_MEDMEMgaussEcr.cxx \
+MEDMEM_MEDMEMprofilEcr.cxx \
+MEDMEM_MEDMEMchampLire.cxx
+
# Executables targets
BIN = med2_1_To_med2_2 med2vtk duplicateMED med_test duplicateMEDMESH
test_operation_fieldint test_gibi_driver test_porflow_driver \
test_grid test_MEDMEM_PolyhedronArray test_MEDMEM_PolyConnectivity \
test_MEDMEM_PolyDriverMedMeshRead test_MEDMEM_PolyDriverMedMeshWrite \
- test_MEDMEM_poly3D test_MEDMEM_nArray test_MEDMEM_Meshing_poly
+ test_MEDMEM_poly3D test_MEDMEM_nArray test_MEDMEM_Meshing_poly test_profil_MedFieldDriver \
+ test_profil_gauss_MedFieldDriver test_GaussLocalization
LDFLAGS+= -L$(top_builddir)/lib/salome
LDFLAGSFORBIN+= -L$(top_builddir)/lib/salome
--- /dev/null
+./test_MEDMEM_nArray > Essai1
+./test_copie_fieldT pointe.med maa1 fieldnodeint > Essai2
+./med_test pointe.med maa1 fieldnodeint > Essai3
+./med_test pointe.med maa1 fieldnodedouble > Essai4
+./test_copie_fieldT pointe.med maa1 fieldnodeint > Essai5
+./test_copie_fieldT pointe.med maa1 fieldnodedouble > Essai6
+./test_MEDMEM_Array > Essai7
+./test_MEDMEM_CellModel > Essai8
+./test_MEDMEM_Meshing Essai9
+h5dump Essai9.med > Essai9.log && rm Essai9.med
+./test_MEDMEM_ModulusArray > Essai10
+./test_MEDMEM_SkyLineArray > Essai12
+./test_operation_fielddouble pointe.med maa1 fieldnodedouble > Essai13
+./test_operation_fielddouble pointe.med maa1 fieldcelldouble > Essai14
+./test_operation_fieldint pointe.med maa1 fieldnodeint > Essai15
+./test_operation_fieldint pointe.med maa1 fieldcellint > Essai16
+#./test_porflow_driver Essai17
+./testUArray > Essai18
+./testUCellModel > Essai19
+./testUCoordinate > Essai20
+./testUGeoNameMeshEntities > Essai21
+./testUMedException > Essai22
+./testUModulusArray > Essai23
+./test_affect_medarray > Essai24
+./test_copie_connectivity pointe.med maa1 > Essai25
+./test_copie_coordinate pointe.med maa1 > Essai26
+./test_copie_family pointe.med maa1 > Essai27
+./test_copie_field_ pointe.med maa1 fieldnodedouble > Essai28
+./test_copie_group pointe.med maa1 > Essai29
+./test_copie_medarray pointe.med maa1 > Essai30
+./test_copie_mesh pointe.med maa1 > Essai31
+./test_copie_support pointe.med maa1 > Essai32
+#./test_gibi_driver pointe.med maa1 > Essai33
+./duplicateMED pointe.med Essai34
+
+#RESUZERODEPL____________________ 1 1 sur NOEUDS, 3 composantes, 1 points de Gauss, taille de profil 18
+#RESUZEROERRE_ELGA_NORE__________ 1 1 sur TETRA10, 6 composantes, 1 points de Gauss, taille de profil 3
+#RESUZEROSIEF_ELGA_DEPL__________ 1 1 sur TETRA10, 6 composantes, 5 points de Gauss, taille de profil 3
+#RESUZEROSIGM_ELNO_DEPL__________ 1 1 sur TETRA10, 6 composantes, 10 points de Gauss, taille de profil 3
+
+rm -f Copy_nomesh_zzzz121b_without_tr6.med Copy_withmesh_zzzz121b_without_tr6.med && ./test_profil_MedFieldDriver zzzz121b_without_tr6.med RESUZERODEPL____________________ 1 1 > Essai35
+rm -f Copy_nomesh_zzzz121b_without_tr6.med Copy_withmesh_zzzz121b_without_tr6.med && ./test_profil_MedFieldDriver zzzz121b_without_tr6.med RESUZEROERRE_ELGA_NORE__________ 1 1 > Essai36
+rm -f Copy_nomesh_zzzz121b_without_tr6.med Copy_withmesh_zzzz121b_without_tr6.med && ./test_profil_gauss_MedFieldDriver zzzz121b_without_tr6.med RESUZEROSIEF_ELGA_DEPL__________ 1 1 > Essai37
+rm -f Copy_nomesh_zzzz121b_without_tr6.med Copy_withmesh_zzzz121b_without_tr6.med && ./test_profil_gauss_MedFieldDriver zzzz121b_without_tr6.med RESUZEROSIGM_ELNO_DEPL__________ 1 1 > Essai38
+
+# Le fichier maill.00.med ne peut pas passer en mode 2
+# - En MODE 1 il faut débrayer la génération du fichier Copy_withmesh_maill.00.med et utiliser celui fourni.
+# - En MODE 2, le problème est qu'à la lecture du fichier (qui contient SEG2 TRIA3 et QUAD4) le driver mesh crée de nouveaux SEG2 or
+# le champ qui a été chargé au préalable a pris le maillage contenu dans le fichier comme référence du coup à la réécriture des numéros
+# de profils il décale d'un nombre d'entités cumulées trop important.
+
+# MODE 1 avec modif du fichier test
+#cp maill.00_nofield.med Copy_withmesh_maill.00.med;./test_profil_MedFieldDriver maill.00.med Indicateur_d_erreur_00 2 2
+# MODE 3 en activant uniquement le mode 3
+##rm -f Copy_withmesh_maill.00.med Copy_nomesh_maill.00.med && cp maill.00_nofield.med Copy_withmesh_maill.00.med;cp maill.00_nomesh.med Copy_nomesh_maill.00.med;./test_profil_MedFieldDriver maill.00.med Indicateur_d_erreur_00 2 2
+
+#Indicateur_d_erreur_00 1 1 TRIA3, 1 composante, 1 point de Gauss, pas de profil
+#Indicateur_d_erreur_00 1 1 QUAD4, 1 composante, 1 point de Gauss, pas de profil
+
+#Indicateur_d_erreur_00 2 2 TRIA3, 1 composante, 1 point de Gauss, taille de profil 4
+#Indicateur_d_erreur_00 2 2 QAUD4, 1 composante, 1 point de Gauss, taille de profil 2
+
+#Indicateur_d_erreur_00 3 3 TRIA3, 1 composante, 3 point de Gauss, pas de profil
+#Indicateur_d_erreur_00 3 3 QAUD4, 1 composante, 4 point de Gauss, pas de prrofil
+
+#Indicateur_d_erreur_00 4 4 TRIA3, 1 composante, 3 point de Gauss, taille de profil 4
+#Indicateur_d_erreur_00 4 4 QAUD4, 1 composante, 4 point de Gauss, taille de profil 2
+
+rm Copy*; ./test_profil_MedFieldDriver maill.00_without_seg2.med Indicateur_d_erreur_00 1 1 > Essai39
+rm Copy*; ./test_profil_MedFieldDriver maill.00_without_seg2.med Indicateur_d_erreur_00 2 2 > Essai40
+rm Copy*; ./test_profil_gauss_MedFieldDriver maill.00_without_seg2.med Indicateur_d_erreur_00 3 3 > Essai41
+rm Copy*; ./test_profil_gauss_MedFieldDriver maill.00_without_seg2.med Indicateur_d_erreur_00 4 4 > Essai42
+
+
--- /dev/null
+#include <stdlib.h>
+#include <string>
+
+#define INTERLACING_TAG FullInterlace
+
+#include "MEDMEM_Exception.hxx"
+#include "MEDMEM_define.hxx"
+#include "MEDMEM_GaussLocalization.hxx"
+#include "MEDMEM_ArrayInterface.hxx"
+
+using namespace std;
+using namespace MEDMEM;
+using namespace MED_EN;
+
+#define _a 0.446948490915965
+#define _b 0.091576213509771
+#define _p1 0.11169079483905
+#define _p2 0.0549758718227661
+
+int main (int argc, char ** argv) {
+
+ typedef MEDMEM_ArrayInterface<double,INTERLACING_TAG,NoGauss>::Array Array;
+
+
+ /* Caractéristiques du model n° 1 de localisation des points de gauss pour le champ n°1*/
+ MED_EN::medGeometryElement typeGeo = MED_TRIA6;
+
+ int ngauss1_1 = 6;
+ string gauss1_1("Model n1");
+ double refcoo1 [12] = { -1.0,1.0, -1.0,-1.0, 1.0,-1.0, -1.0,0.0, 0.0,-1.0, 0.0,0.0 };
+
+ double gscoo1_1[12] = { 2*_b-1, 1-4*_b, 2*_b-1, 2*_b-1, 1-4*_b,
+ 2*_b-1, 1-4*_a, 2*_a-1, 2*_a-1, 1-4*_a, 2*_a-1, 2*_a-1 };
+ double wg1_1[6] = { 4*_p2, 4*_p2, 4*_p2, 4*_p1, 4*_p1, 4*_p1 };
+
+
+ assert( ( (typeGeo%100)*(typeGeo/100) ) == 12 );
+
+ GAUSS_LOCALIZATION<INTERLACING_TAG> myloc1 = GAUSS_LOCALIZATION<INTERLACING_TAG>(gauss1_1,typeGeo,ngauss1_1,
+ Array(refcoo1,typeGeo/100,(typeGeo%100) ),
+ Array(gscoo1_1,typeGeo/100,ngauss1_1),
+ vector<double> (wg1_1,wg1_1+ngauss1_1)
+ );
+ GAUSS_LOCALIZATION<INTERLACING_TAG> myloc1bis = GAUSS_LOCALIZATION<INTERLACING_TAG>(gauss1_1,typeGeo,ngauss1_1,
+ refcoo1,gscoo1_1,
+ wg1_1);
+
+ cout << "myloc1 == myloc1bis " << (myloc1 == myloc1bis) << endl;
+ cout << "myloc1 : " << endl << myloc1 << endl;
+}
--- /dev/null
+
+#include <stdlib.h>
+#include<string>
+
+#include "MEDMEM_Exception.hxx"
+#include "MEDMEM_Mesh.hxx"
+#include "MEDMEM_MedMeshDriver.hxx"
+#include "MEDMEM_Field.hxx"
+#include "MEDMEM_MedFieldDriver.hxx"
+#include "MEDMEM_Support.hxx"
+#include "MEDMEM_define.hxx"
+
+using namespace std;
+using namespace MEDMEM;
+using namespace MED_EN;
+
+void affiche_field_(FIELD_ * myField, const SUPPORT * mySupport)
+{
+ cout << "Field "<< myField->getName() << " : " <<myField->getDescription() << endl ;
+ int NumberOfComponents = myField->getNumberOfComponents() ;
+ cout << "- Nombre de composantes : "<< NumberOfComponents << endl ;
+ for (int i=1; i<NumberOfComponents+1; i++) {
+ cout << " - composante "<<i<<" :"<<endl ;
+ cout << " - nom : "<<myField->getComponentName(i)<< endl;
+ cout << " - description : "<<myField->getComponentDescription(i) << endl;
+ cout << " - units : "<<myField->getMEDComponentUnit(i) << endl;
+ }
+ cout << "- iteration :" << endl ;
+ cout << " - numero : " << myField->getIterationNumber()<< endl ;
+ cout << " - ordre : " << myField->getOrderNumber()<< endl ;
+ cout << " - temps : " << myField->getTime()<< endl ;
+
+ cout << "- Type : " << myField->getValueType()<< endl;
+
+ cout << "- Adresse support : " << mySupport << endl;
+}
+
+template <class INTERLACING_TAG>
+void affiche_fieldT(FIELD<double, INTERLACING_TAG> * myField,
+ const SUPPORT * mySupport)
+{
+ const double * value = 0;
+ const int * number = 0;
+
+ affiche_field_((FIELD_ *) myField, mySupport);
+
+ cout.setf(ios::fixed);
+ cout << "- Valeurs :"<<endl;
+ bool onAll = mySupport->isOnAllElements();
+ int NumberOf = mySupport->getNumberOfElements(MED_ALL_ELEMENTS);
+ cout << "mySupport->getNumberOfElements(MED_ALL_ELEMENTS)" << NumberOf << endl;
+ int NumberOfComponents = myField->getNumberOfComponents() ;
+ cout << "myField->getNumberOfComponents()" << NumberOfComponents << endl;
+ if (!onAll) number = mySupport->getNumber(MED_ALL_ELEMENTS);
+
+ if ( myField->getInterlacingType() == MED_EN::MED_FULL_INTERLACE ) {
+ for (int i=1; i<NumberOf+1; i++) {
+ if (onAll)
+ value = myField->getRow(i) ;
+ else
+ value = myField->getRow(number[i-1]);
+ for (int j=0; j<NumberOfComponents; j++)
+ cout << value[j]<< " ";
+ cout<<endl;
+ }
+ }
+ else {
+ for (int j=1; j<NumberOfComponents+1; j++) {
+ value = myField->getColumn(j) ;
+ for (int i=0; i<NumberOf; i++)
+ cout << value[i]<< " ";
+ cout<<endl;
+ }
+ }
+}
+
+int main (int argc, char ** argv) {
+
+ if ((argc !=3) && (argc != 5)) {
+ cerr << "Usage : " << argv[0]
+ << " filename fieldName [iterationNumber] [orderNumber]" << endl << endl;
+ exit(-1);
+ }
+
+ string fileName = argv[1] ;
+ string fieldName = argv[2] ;
+ int iterationNumber=-1,orderNumber=-1;
+ if ( argv[3] ) iterationNumber = atoi(argv[3]);
+ if ( argv[4] ) orderNumber = atoi(argv[4]);
+
+ string meshName=""; //"MAILTRQU";
+ //goto mode3;
+ /////////////////////////////////////////////////////////////////////////////////////////
+ // TEST PREMIER MODE :
+ // Le fichier MED lu contient le maillage associé au champ demandé (qui contient des profils )
+ // Le driver du FIELD automatiquement crée est capable de lire les profils MEDFICHIER
+ // (le SUPPORT est crée automatiquement, le nom du maillage associé est disponible dans
+ // le SUPPORT mais la relation SUPPORT-MESH est non initialisée car le MESH n'est pas chargé).
+ // Le driver utilise les informations du maillage dans le fichier pour transcrire les profils
+ // de la numérotation locale MEDFICHIER à la numérotation globale MEDMEMOIRE).
+ // A l'écriture, il se repose également sur le maillage contenu dans le fichier
+ // pour effecuter la renumérotation.
+ {
+ FIELD<double> * myField1 = new FIELD<double>(MED_DRIVER,fileName,fieldName,
+ iterationNumber, orderNumber);
+ affiche_fieldT(myField1, myField1->getSupport());
+
+ // Pour éviter de modifier le fichier d'origine,
+ // on en crée une copie avec uniquement le maillage.
+ // Rem : Pour le test, le chargement du maillage n'est pas nécessaire
+ // On pourrait réécrire le Champ dans le fichier d'origine
+ // sous un autre nom.
+ // Attention si le driver MED_MESH modifie le nombre d'éléments d'un type géométrique :
+ // le calcul de renumérotation à l'écriture du champ risque d'être faux !
+ meshName = myField1->getSupport()->getMeshName();
+ MESH * myMesh = new MESH(MED_DRIVER,fileName,meshName);
+ MED_MESH_WRONLY_DRIVER myMeshDriver1("Copy_withmesh_"+fileName,myMesh);
+ int current=myMesh->addDriver(myMeshDriver1);
+ myMesh->write(current);
+ delete myMesh;
+
+ // On ajoute un driver en écriture, comme la relation SUPPORT-MESH n'est pas
+ // initialisée, le driver doit trouver le maillage dans le fichier cible
+ // pour réaliser la transcription des profils MEDMEMOIRE à MEDFICHIER.
+ MED_FIELD_WRONLY_DRIVER<double> myFieldDriver2("Copy_withmesh_"+fileName,myField1) ;
+ current = myField1->addDriver(myFieldDriver2);
+ myField1->write(current);
+ delete myField1;
+ }
+
+ mode2:
+ /////////////////////////////////////////////////////////////////////////////
+ // TEST DEUXIEME MODE :
+ // Lecture idem 1er mode
+ // A l'écriture, le fichier cible ne contient pas le maillage mais la
+ // relation SUPPORT-MESH étant établie le driver utilise les informations
+ // dans le maillage en mémoire pour transcrire les profils.
+ // Selon le modèle MED FICHIER, ce mode est interdit : le fichier doit au moins
+ // contenir un lien sur le maillage (information pas encore exploitée dans MEDMEMOIRE
+ // : pas de gestion de montage/démontage des fichiers )
+ // Attention si le driver MED_MESH modifie le nombre d'éléments d'un type géométrique :
+ // le calcul de renumérotation à l'écriture du champ risque d'être faux car les
+ // profils crées à la lecture son basés sur le nombre d'éléments par type géoémtrique
+ // du maillage contenu dans le fichier à la lecture.
+ // Une solution consisterait à prendre en compte le montage de fichiers distants
+ // et de prendre en compte la différence de nombre d'éléments par type géométrique
+ // entre le maillage MEDMEM et le maillage MEDFICHIER
+ // (Hum ! : Il serait plus simple que MEDMEMOIRE ne recalcule pas systématiquement
+ // ce que l'on ne lui demande pas, ce qui permettrait aussi de réécrire à l'identique
+ // un fichier que l'on vient de lire)
+ {
+ FIELD<double> * myField2 = new FIELD<double>(MED_DRIVER,fileName,fieldName,
+ iterationNumber, orderNumber);
+
+ meshName = myField2->getSupport()->getMeshName();
+ MESH * myMesh2 = new MESH(MED_DRIVER,fileName,meshName);
+
+ const SUPPORT * mySupport2=myField2->getSupport();
+ mySupport2->setMesh(myMesh2);
+
+ // On ajoute un driver en écriture, comme la relation SUPPORT-MESH est
+ // initialisée, le driver utilise le maillage en mémoire
+ // pour réaliser la transcription des profils MEDMEMOIRE à MEDFICHIER.
+ MED_FIELD_WRONLY_DRIVER<double> myFieldDriver3("Copy_nomesh_"+fileName,myField2) ;
+ int current = myField2->addDriver(myFieldDriver3);
+ myField2->write(current);
+
+ //Pour regarder le fichier produit avec MDUMP decommenter ces trois lignes
+ //car le fichier qui est produit n'est pas à la norme MED
+ //Il doit contenir soit le maillage associé soit un lien vers le maillage associé.
+ //MED_MESH_WRONLY_DRIVER myMeshDriver2("Copy_nomesh_"+fileName,myMesh2);
+ //current=myMesh2->addDriver(myMeshDriver2);
+ //myMesh2->write(current);
+
+ delete myField2;
+ delete myMesh2;
+
+
+ }
+ mode3:
+ // TEST TROISIEME MODE :
+ // A la lecture, le fichier MED lu ne contient pas le maillage associé au champ demandé
+ // (mais un lien MEDFICHIER qui n'est pas exploité à ce jour).
+ // Cependant avant sa lecture le FIELD a été associé à un SUPPORT
+ // avec le lien au MESH préalablement chargé.
+ // Le driver du FIELD (automatiquement crée) est capable de lire les profils MEDFICHIER
+ // et utilise la relation SUPPORT-MESH initialisée pour transcrire les profils
+ // de la numérotation locale MEDFICHIER à la numérotation globale MEDMEMOIRE).
+ // REM: Une fois le champ chargé, il possède un nouveau support, le premier peut être libéré.
+ // En effet le driver du FIELD se fit uniquement au type géométriques définis dans le champ MEDFICHIER
+ // pour créer son SUPPORT car un SUPPORT crée "onAll" à partir d'un MESH repose sur tous
+ // les types géométriques du MESH ce qui n'est pas forcément le cas d'un champ MEDFICHIER
+ // (même sans profil) lu à posteriori.
+ {
+ med_2_2::med_err err=-1;
+ med_2_2::med_idt id = med_2_2::MEDouvrir(const_cast<char *> ( ("Copy_nomesh_"+fileName).c_str()),
+ med_2_2::MED_LECTURE_ECRITURE);
+ if (id <=0) cout << "Erreur dans MEDouvrir pour le fichier " << "Copy_nomesh_"+fileName <<endl;
+
+ err=med_2_2::MEDlienEcr(id, const_cast<char *> ( ("Copy_withmesh_"+fileName).c_str()),
+ const_cast<char *> (meshName.c_str()) );
+ if (err !=0) cout << "Erreur dans MEDlienEcr pour le maillage distant " << meshName
+ <<" contenu dans le fichier " << "Copy_withmesh_"+fileName <<endl;
+
+
+ err=med_2_2::MEDfermer(id);
+
+ MESH * myMesh3 = new MESH(MED_DRIVER,fileName,meshName);
+ const SUPPORT * mySupport3= new SUPPORT(myMesh3,"Temporary Support",MED_CELL);
+ FIELD<double> * myField3 = new FIELD<double>(mySupport3,MED_DRIVER,"Copy_nomesh_"+fileName,fieldName,
+ iterationNumber, orderNumber);
+ delete mySupport3; // Il est déjà possible de libérer ce SUPPORT
+
+ //TEST à la réecriture :
+ string cpy("__Copy");
+ vector < string > pflNames = myField3->getSupport()->getProfilNames();
+ for (int i=0; i< pflNames.size(); ++i) {
+ pflNames[i].resize(pflNames[i].size()-cpy.size());
+ pflNames[i]+=cpy;
+ }
+ const_cast<SUPPORT*>(myField3->getSupport())->setProfilNames(pflNames);
+ MED_FIELD_WRONLY_DRIVER<double> myFieldDriver4("Copy_nomesh_"+fileName,myField3) ;
+ myFieldDriver4.setFieldName(myField3->getName()+"__Copy");
+ int current = myField3->addDriver(myFieldDriver4);
+ myField3->write(current);
+
+ delete myMesh3;
+ delete myField3;
+
+
+ //ESSAYER AVEC MAILLAGE DS FICHIER ET LIEN SUPORT-MESH PRESENTS SIMULTANEMENT
+ //EN VERSION COHERENTE ET NON COHERENTE
+ }
+}
--- /dev/null
+
+#include <stdlib.h>
+#include<string>
+
+#include "MEDMEM_Exception.hxx"
+#include "MEDMEM_Mesh.hxx"
+#include "MEDMEM_MedMeshDriver.hxx"
+#include "MEDMEM_Field.hxx"
+#include "MEDMEM_MedFieldDriver.hxx"
+#include "MEDMEM_Support.hxx"
+#include "MEDMEM_define.hxx"
+#include "MEDMEM_GaussLocalization.hxx"
+
+using namespace std;
+using namespace MEDMEM;
+using namespace MED_EN;
+
+#define INTERLACING_MODE FullInterlace
+int fct2(int i,const int * number) { return i;};
+int fct1(int i,const int * number) { return number[i]; };
+
+void affiche_field_(FIELD_ * myField)
+{
+ cout << "Field "<< myField->getName() << " : " <<myField->getDescription() << endl ;
+ int NumberOfComponents = myField->getNumberOfComponents() ;
+ cout << "- Nombre de composantes : "<< NumberOfComponents << endl ;
+ for (int i=1; i<NumberOfComponents+1; i++) {
+ cout << " - composante "<<i<<" :"<<endl ;
+ cout << " - nom : "<<myField->getComponentName(i)<< endl;
+ cout << " - description : "<<myField->getComponentDescription(i) << endl;
+ cout << " - units : "<<myField->getMEDComponentUnit(i) << endl;
+ }
+ cout << "- iteration :" << endl ;
+ cout << " - numero : " << myField->getIterationNumber()<< endl ;
+ cout << " - ordre : " << myField->getOrderNumber()<< endl ;
+ cout << " - temps : " << myField->getTime()<< endl ;
+
+ cout << "- Type : " << myField->getValueType()<< endl;
+ //PRESENCE DE POINTS DE GAUSS
+}
+
+// Cas de traitement des valeurs sans spécificité concernant
+// les points de Gauss ou les profils
+// Pas de spécificité concernant le type géométrique
+template <class INTERLACING_TAG>
+void affiche_fieldT(FIELD<double,INTERLACING_TAG> * myField)
+{
+ const double * value = 0;
+ affiche_field_((FIELD_ *) myField);
+
+ cout.setf(ios::fixed);
+
+ int numberOf = myField->getNumberOfValues();
+ int numberOfComponents = myField->getNumberOfComponents() ;
+ int valueLength = myField->getValueLength();
+ int numberOfGeometricType = myField->getNumberOfGeometricTypes();
+ const int * nbOfElements = myField->getNumberOfElements();
+ const MED_EN::medGeometryElement * typeList = myField->getGeometricTypes();
+ // Suivant le traitement, on peut faire sortir si il y a des points de Gauss
+ // ou des profils
+
+ cout << "myField->getValueLength (MED_ALL_ELEMENTS) : " << valueLength << endl;
+ cout << "myField->getNumberOfElements (MED_ALL_ELEMENTS) : " << numberOf << endl;
+ cout << "myField->getNumberOfComponents () : " << numberOfComponents << endl;
+ cout << "myField->getNumberOfGeometricType () : " << numberOfGeometricType << endl;
+ for (int i=0; i < numberOfGeometricType; i++) {
+ cout << "Number Of Elements on type "<< MED_EN::geoNames[typeList[i]]
+ <<" : "<< nbOfElements[i] << endl;
+ cout << "Number Of Gauss Points on type "<< MED_EN::geoNames[typeList[i]]
+ <<" : "<< myField->getNumberOfGaussPoints(typeList[i]) << endl;
+ cout << "Localization description : " << endl << myField->getGaussLocalization(typeList[i]) << endl;
+ }
+
+ cout << "- Valeurs :"<<endl;
+ for (int index=0; index < valueLength; index++) {
+ cout << "value["<<index<<"] = "<< value[index];
+ cout<<endl;
+ }
+
+}
+
+// Spécialisation du traitement pour le mode FullInterlace
+// Spécifité de traitement par rapport aux profils (utilisation du SUPPORT)
+// Pas de spécificité concernant le type géométrique
+// Pas de spécificité concernant les points de Gauss
+template <>
+void affiche_fieldT(FIELD<double, FullInterlace> * myField)
+{
+ const double * value = 0;
+ const int * number = 0;
+
+ affiche_field_((FIELD_ *) myField);
+ const SUPPORT * mySupport=myField->getSupport();
+
+ cout.setf(ios::fixed);
+
+
+ int numberOfComponents = myField->getNumberOfComponents() ;
+ int valueLength = myField->getValueLength();
+ const int * nbGaussPoints = myField->getNumberOfGaussPoints();
+
+ int numberOf = mySupport->getNumberOfElements(MED_ALL_ELEMENTS);
+ int numberOfGeometricType = mySupport->getNumberOfTypes();
+ const int * nbOfElements = mySupport->getNumberOfElements();
+ const MED_EN::medGeometryElement * typeList = mySupport->getTypes();
+ bool onAll = mySupport->isOnAllElements();
+
+ cout << "mySupport->getValueLength (MED_ALL_ELEMENTS) : " << valueLength << endl;
+ cout << "mySupport->getNumberOfElements (MED_ALL_ELEMENTS) : " << numberOf << endl;
+ cout << "mySupport->getNumberOfComponents () : " << numberOfComponents << endl;
+ cout << "mySupport->getNumberOfGeometricType () : " << numberOfGeometricType << endl;
+ assert(numberOf == myField->getNumberOfValues() );
+
+ // S'il existe des profils, je récupère la liste des numéros d'éléments
+ // pour tous les types géométriques
+ for (int i=0; i < numberOfGeometricType; i++) {
+ cout << "Number Of Elements on type "<< MED_EN::geoNames[typeList[i]]
+ <<" : "<< nbOfElements[i] << endl;
+ cout << "Number Of Gauss Points on type "<< MED_EN::geoNames[typeList[i]]
+ <<" : "<< nbGaussPoints[i] << endl;
+ cout << "Localization description : " << endl << myField->getGaussLocalization(typeList[i]) << endl;
+ }
+
+ // On récupère la liste complète
+ if (!onAll) number = mySupport->getNumber(MED_ALL_ELEMENTS);
+
+ int elNo = -1;
+ cout << "- Valeurs :" << endl;
+ for (int i=1; i<=numberOf; i++) {
+ if (onAll) elNo = i; else elNo = number[i-1];
+ //cout << endl << "myField->getRow("<<elNo<<") : "<< myField->getRow(elNo) << endl;
+ value = myField->getRow(elNo) ;
+ //UP: getRow prend un numéro d'élément qui existe, getRow(1) n'existe pas forcément si il y a un profil
+ //qui ne défini pas cet indice
+ //cout << endl << " Valeur de getNbGaussI("<<elNo<<") :" << myField->getNbGaussI(elNo) << endl;
+ for (int j=0; j<numberOfComponents*myField->getNbGaussI(elNo); j++)
+ //UP : Prend en compte le nombre de points de Gauss de l'élément elNo
+ cout << "value["<< elNo << "] = " << value[j] << " ";
+ cout<<endl;
+ }
+
+}
+
+// Spécialisation du traitement pour le mode NoInterlace
+// Spécifité de traitement par rapport aux profils (utilisation du SUPPORT)
+// Pas de spécificité concernant le type géométrique
+// Pas de spécificité concernant les points de Gauss
+template <>
+void affiche_fieldT(FIELD<double, NoInterlace> * myField)
+{
+ const double * value = 0;
+ const int * number = 0;
+
+ affiche_field_((FIELD_ *) myField);
+ const SUPPORT * mySupport=myField->getSupport();
+
+ cout.setf(ios::fixed);
+
+
+ int numberOfComponents = myField->getNumberOfComponents() ;
+ int valueLength = myField->getValueLength();
+ const int * nbGaussPoints = myField->getNumberOfGaussPoints();
+
+ int numberOf = mySupport->getNumberOfElements(MED_ALL_ELEMENTS);
+ int numberOfGeometricType = mySupport->getNumberOfTypes();
+ const int * nbOfElements = mySupport->getNumberOfElements();
+ const MED_EN::medGeometryElement * typeList = mySupport->getTypes();
+ bool onAll = mySupport->isOnAllElements();
+
+ cout << "mySupport->getValueLength (MED_ALL_ELEMENTS) : " << valueLength << endl;
+ cout << "mySupport->getNumberOfElements (MED_ALL_ELEMENTS) : " << numberOf << endl;
+ cout << "mySupport->getNumberOfComponents () : " << numberOfComponents << endl;
+ cout << "mySupport->getNumberOfGeometricType () : " << numberOfGeometricType << endl;
+ cout << "mySupport->getNumberOfElements(MED_ALL_ELEMENTS) : " << numberOf << endl;
+ assert(numberOf == myField->getNumberOfValues() );
+
+ // S'il existe des profils, je récupère la liste des numéros d'éléments
+ // pour tous les types géométriques
+ for (int i=0; i < numberOfGeometricType; i++) {
+ cout << "Number Of Elements on type "<< MED_EN::geoNames[typeList[i]]
+ <<" : "<< nbOfElements[i] << endl;
+ cout << "Number Of Gauss Points on type "<< MED_EN::geoNames[typeList[i]]
+ <<" : "<< nbGaussPoints[i] << endl;
+ cout << "Localization description : " << endl << myField->getGaussLocalization(typeList[i]) << endl;
+ }
+
+
+ int (* fct)(int,const int *);
+
+ if (!onAll) {
+ number = mySupport->getNumber(MED_ALL_ELEMENTS);
+ fct=fct1;
+ } else
+ fct=fct2;
+
+ int oneDimlength = valueLength/numberOfComponents;
+ for (int j=1; j<=numberOfComponents; j++) {
+ value = myField->getColumn(j) ;
+ for (int i=0; i<oneDimlength; i++)
+ cout << "value["<< fct(i,number) << ","<<j<<"]" << value[ fct(i,number) ] << " ";
+ cout<<endl;
+ }
+
+}
+
+
+template <class T, class INTERLACING_TAG>
+void affiche_fieldT2(FIELD< T, INTERLACING_TAG> * myField)
+{};
+
+
+// Spécialisation du traitement pour le mode FullInterlace
+// Spécifité de traitement par rapport aux profils (utilisation du SUPPORT)
+// Spécificité concernant le type géométrique
+// Spécificité concernant les points de Gauss
+template <>
+void affiche_fieldT2(FIELD<double, FullInterlace> * myField)
+{
+ const int * number = 0;
+
+ affiche_field_((FIELD_ *) myField);
+ const SUPPORT * mySupport=myField->getSupport();
+
+ cout.setf(ios::fixed);
+
+
+ int numberOfComponents = myField->getNumberOfComponents() ;
+ int valueLength = myField->getValueLength();
+ const int * nbGaussPoints = myField->getNumberOfGaussPoints();
+
+ int numberOf = mySupport->getNumberOfElements(MED_ALL_ELEMENTS);
+ int numberOfGeometricType = mySupport->getNumberOfTypes();
+ const int * nbOfElements = mySupport->getNumberOfElements();
+ const MED_EN::medGeometryElement * typeList = mySupport->getTypes();
+ bool onAll = mySupport->isOnAllElements();
+
+ cout << "mySupport->getValueLength (MED_ALL_ELEMENTS) : " << valueLength << endl;
+ cout << "mySupport->getNumberOfElements (MED_ALL_ELEMENTS) : " << numberOf << endl;
+ cout << "mySupport->getNumberOfComponents () : " << numberOfComponents << endl;
+ cout << "mySupport->getNumberOfGeometricType () : " << numberOfGeometricType << endl;
+ cout << "mySupport->getNumberOfElements(MED_ALL_ELEMENTS) : " << numberOf << endl;
+ assert(numberOf == myField->getNumberOfValues() );
+
+ // S'il existe des profils, je récupère la liste des numéros d'éléments
+ // pour tous les types géométriques
+ for (int i=0; i < numberOfGeometricType; i++) {
+ cout << "Number Of Elements on type "<< MED_EN::geoNames[typeList[i]]
+ <<" : "<< nbOfElements[i] << endl;
+ cout << "Number Of Gauss Points on type "<< MED_EN::geoNames[typeList[i]]
+ <<" : "<< nbGaussPoints[i] << endl;
+ }
+
+
+ int (* fct)(int,const int *);
+
+ if (!onAll) {
+ number = mySupport->getNumber(MED_ALL_ELEMENTS);
+ fct=fct1;
+ } else
+ fct=fct2;
+
+ cout << "- Valeurs :"<<endl;
+
+ int elemno = 1;
+ for (int ntyp=1; ntyp <= numberOfGeometricType; ntyp++ ) {
+ for (int i=0; i < nbOfElements[ntyp-1] ; i++ ) {
+ for (int k=1; k <= nbGaussPoints[ntyp-1]; k++)
+ for (int j=1; j <= numberOfComponents; j++) {
+ cout << " value["<< fct(elemno-1,number) << "," <<j<<","<<k<<"] = "
+ << myField->getValueIJK(fct(elemno-1,number),j,k);
+ }
+ elemno++;
+ cout << endl;
+ }
+ }
+
+ assert((elemno-1) == numberOf);
+
+}
+
+
+int main (int argc, char ** argv) {
+
+ if ((argc !=3) && (argc != 5)) {
+ cerr << "Usage : " << argv[0]
+ << " filename fieldName [iterationNumber] [orderNumber]" << endl << endl;
+ exit(-1);
+ }
+
+ string fileName = argv[1] ;
+ string fieldName = argv[2] ;
+ int iterationNumber=-1,orderNumber=-1;
+ if ( argv[3] ) iterationNumber = atoi(argv[3]);
+ if ( argv[4] ) orderNumber = atoi(argv[4]);
+
+ string meshName="";//"MAILTRQU";
+ //goto mode2;
+ /////////////////////////////////////////////////////////////////////////////////////////
+ // TEST PREMIER MODE :
+ // Le fichier MED lu contient le maillage associé au champ demandé (qui contient des profils )
+ // Le driver du FIELD automatiquement crée est capable de lire les profils MEDFICHIER
+ // (le SUPPORT est crée automatiquement, le nom du maillage associé est disponible dans
+ // le SUPPORT mais la relation SUPPORT-MESH est non initialisée car le MESH n'est pas chargé).
+ // Le driver utilise les informations du maillage dans le fichier pour transcrire les profils
+ // de la numérotation locale MEDFICHIER à la numérotation globale MEDMEMOIRE).
+ // A l'écriture, il se repose également sur le maillage contenu dans le fichier
+ // pour effecuter la renumérotation.
+ {
+ FIELD<double,INTERLACING_MODE> * myField1 = new FIELD<double,INTERLACING_MODE>(MED_DRIVER,fileName,fieldName,
+ iterationNumber, orderNumber);
+ affiche_fieldT(myField1);
+ cout << endl;
+ affiche_fieldT2(myField1);
+
+ // Pour éviter de modifier le fichier d'origine,
+ // on en crée une copie avec uniquement le maillage.
+ // Rem : Pour le test, le chargement du maillage n'est pas nécessaire
+ // On pourrait réécrire le Champ dans le fichier d'origine
+ // sous un autre nom.
+ // Attention si le driver MED_MESH modifie le nombre d'éléments d'un type géométrique :
+ // le calcul de renumérotation à l'écriture du champ risque d'être faux !
+ meshName = myField1->getSupport()->getMeshName();
+ MESH * myMesh = new MESH(MED_DRIVER,fileName,meshName);
+ MED_MESH_WRONLY_DRIVER myMeshDriver1("Copy_withmesh_"+fileName,myMesh);
+ int current=myMesh->addDriver(myMeshDriver1);
+ myMesh->write(current);
+ delete myMesh;
+
+ // On ajoute un driver en écriture, comme la relation SUPPORT-MESH n'est pas
+ // initialisée, le driver doit trouver le maillage dans le fichier cible
+ // pour réaliser la transcription des profils MEDMEMOIRE à MEDFICHIER.
+ MED_FIELD_WRONLY_DRIVER<double> myFieldDriver2("Copy_withmesh_"+fileName,myField1) ;
+ current = myField1->addDriver(myFieldDriver2);
+ myField1->write(current);
+ delete myField1;
+ }
+
+ mode2:
+ /////////////////////////////////////////////////////////////////////////////
+ // TEST DEUXIEME MODE :
+ // Lecture idem 1er mode
+ // A l'écriture, le fichier cible ne contient pas le maillage mais la
+ // relation SUPPORT-MESH est établie, le driver peut donc utiliser les informations
+ // dans le maillage pour transcrire les profils.
+ // Selon le modèle MED FICHIER, ce mode est interdit : le fichier doit au moins
+ // contenir un lien sur le maillage (information pas encore exploitée dans MEDMEMOIRE
+ // : pas de gestion de montage/démontage des fichiers )
+ // Attention si le driver MED_MESH modifie le nombre d'éléments d'un type géométrique :
+ // le calcul de renumérotation à l'écriture du champ risque d'être faux car les
+ // profils crées à la lecture sont basés sur le nombre d'éléments par type géoémtrique
+ // du maillage contenu dans le fichier à la lecture.
+ // Une solution consisterait à prendre en compte le montage de fichiers distants
+ // et de prendre en compte la différence de nombre d'éléments par type géométrique
+ // entre le maillage MEDMEM et le maillage MEDFICHIER
+ // (Hum ! : Il serait plus simple que MEDMEMOIRE ne recalcule pas systématiquement
+ // ce que l'on ne lui demande pas, ce qui permettrait aussi de réécrire à l'identique
+ // un fichier que l'on vient de lire)
+ {
+ FIELD<double,INTERLACING_MODE> * myField2 = new FIELD<double,INTERLACING_MODE>(MED_DRIVER,fileName,fieldName,
+ iterationNumber, orderNumber);
+
+ meshName = myField2->getSupport()->getMeshName();
+ MESH * myMesh2 = new MESH(MED_DRIVER,fileName,meshName);
+
+ const SUPPORT * mySupport2=myField2->getSupport();
+ mySupport2->setMesh(myMesh2);
+
+ // On ajoute un driver en écriture, comme la relation SUPPORT-MESH est
+ // initialisée, le driver utilise le maillage en mémoire
+ // pour réaliser la transcription des profils MEDMEMOIRE à MEDFICHIER.
+ MED_FIELD_WRONLY_DRIVER<double> myFieldDriver3("Copy_nomesh_"+fileName,myField2) ;
+ int current = myField2->addDriver(myFieldDriver3);
+ myField2->write(current);
+
+ //Pour regarder le fichier produit avec MDUMP decommenter ces trois lignes
+ //car le fichier qui est produit n'est pas à la norme MED
+ //Il doit contenir soit le maillage associé soit un lien vers le maillage associé.
+ //MED_MESH_WRONLY_DRIVER myMeshDriver2("Copy_nomesh_"+fileName,myMesh2);
+ //current=myMesh2->addDriver(myMeshDriver2);
+ //myMesh2->write(current);
+
+ delete myField2;
+ delete myMesh2;
+
+
+ }
+ mode3:
+ // TEST TROISIEME MODE :
+ // A la lecture, le fichier MED lu ne contient pas le maillage associé au champ demandé
+ // (mais un lien MEDFICHIER qui n'est pas exploité à ce jour).
+ // Cependant avant sa lecture le FIELD a été associé à un SUPPORT
+ // avec le lien au MESH préalablement chargé.
+ // Le driver du FIELD (automatiquement crée) est capable de lire les profils MEDFICHIER
+ // et utilise la relation SUPPORT-MESH initialisée pour transcrire les profils
+ // de la numérotation locale MEDFICHIER à la numérotation globale MEDMEMOIRE).
+ // REM: Une fois le champ chargé, il possède un nouveau support, le premier peut être libéré.
+ // En effet le driver du FIELD se fit uniquement au type géométriques définis dans le champ MEDFICHIER
+ // pour créer son SUPPORT car un SUPPORT crée "onAll" à partir d'un MESH repose sur tous
+ // les types géométriques du MESH ce qui n'est pas forcément le cas d'un champ MEDFICHIER
+ // (même sans profil) lu à posteriori.
+ {
+ med_2_2::med_err err=-1;
+ med_2_2::med_idt id = med_2_2::MEDouvrir(const_cast<char *> ( ("Copy_nomesh_"+fileName).c_str()),
+ med_2_2::MED_LECTURE_ECRITURE);
+ if (id <=0) cout << "Erreur dans MEDouvrir pour le fichier " << "Copy_nomesh_"+fileName <<endl;
+
+ err=med_2_2::MEDlienEcr(id, const_cast<char *> ( ("Copy_withmesh_"+fileName).c_str()),
+ const_cast<char *> (meshName.c_str()) );
+ if (err !=0) cout << "Erreur dans MEDlienEcr pour le maillage distant " << meshName
+ <<" contenu dans le fichier " << "Copy_withmesh_"+fileName <<endl;
+
+
+ err=med_2_2::MEDfermer(id);
+
+ MESH * myMesh3 = new MESH(MED_DRIVER,fileName,meshName);
+ const SUPPORT * mySupport3= new SUPPORT(myMesh3,"Temporary Support",MED_CELL);
+ FIELD<double,INTERLACING_MODE> * myField3 = new FIELD<double,INTERLACING_MODE>(mySupport3,MED_DRIVER,"Copy_nomesh_"+fileName,fieldName, iterationNumber, orderNumber);
+ delete mySupport3; // Il est déjà possible de libérer ce SUPPORT
+
+ //TEST à la réecriture (renommage des profils
+ // à cause de MEDprofilEcr qui ne prend pas en compte le mode
+ // MED_LECTURE_AJOUT) ):
+ string cpy("__Copy");
+ vector < string > pflNames = myField3->getSupport()->getProfilNames();
+ for (int i=0; i< pflNames.size(); ++i) {
+ pflNames[i].resize(pflNames[i].size()-cpy.size());
+ pflNames[i]+=cpy;
+ }
+ const_cast<SUPPORT*>(myField3->getSupport())->setProfilNames(pflNames);
+
+ MED_FIELD_WRONLY_DRIVER<double> myFieldDriver4("Copy_nomesh_"+fileName,myField3) ;
+ myFieldDriver4.setFieldName(myField3->getName()+"__Copy");
+ int current = myField3->addDriver(myFieldDriver4);
+ myField3->write(current);
+
+ delete myMesh3;
+ delete myField3;
+
+
+ //ESSAYER AVEC MAILLAGE DS FICHIER ET LIEN SUPORT-MESH PRESENTS SIMULTANEMENT
+ //EN VERSION COHERENTE ET NON COHERENTE
+ }
+}
}
}
-
-//=============================================================================
-/*!
- * CORBA: Array containing indexes for elements included in the support
- */
-//=============================================================================
-
-CORBA::Long SUPPORT_i::getNumberOfGaussPoint(SALOME_MED::medGeometryElement geomElement)
-throw (SALOME::SALOME_Exception)
-{
- if (_support==NULL)
- THROW_SALOME_CORBA_EXCEPTION("No associated Support", \
- SALOME::INTERNAL_ERROR);
- try
- {
- return _support->getNumberOfGaussPoint(convertIdlEltToMedElt(geomElement));
- }
- catch (MEDEXCEPTION &ex)
- {
- MESSAGE("Unable to access number of Gauss points");
- THROW_SALOME_CORBA_EXCEPTION(ex.what(), SALOME::INTERNAL_ERROR);
- }
-}
-//=============================================================================
-/*!
- * CORBA: Global Nodes Index (optionnaly designed by the user)
- */
-//=============================================================================
-SALOME_MED::long_array * SUPPORT_i::getNumbersOfGaussPoint()
-throw (SALOME::SALOME_Exception)
-{
- if (_support==NULL)
- THROW_SALOME_CORBA_EXCEPTION("No associated Support", \
- SALOME::INTERNAL_ERROR);
- SALOME_MED::long_array_var myseq= new SALOME_MED::long_array;
- try
- {
- int mySeqLength=_support->getNumberOfTypes();
- myseq->length(mySeqLength);
- const medGeometryElement * elemts = _support->getTypes();
- for (int i=0;i<mySeqLength;i++)
- {
- myseq[i]= _support->getNumberOfGaussPoint(elemts[i]);
- }
- }
- catch (MEDEXCEPTION &ex)
- {
- MESSAGE("Unable to access number of Gauss points");
- THROW_SALOME_CORBA_EXCEPTION(ex.what(), SALOME::INTERNAL_ERROR);
- }
- return myseq._retn();
-}
//=============================================================================
/*!
* CORBA: add the Support in the StudyManager
if (blankSupport)
SUPPORTClient::blankCopy();
-// setIdentifier(IOR_Family->getIdentifier());
+ setIdentifier(IOR_Family->getIdentifier());
-// int nAttr, nGr, n;
-// int *i;
-// std::string *s;
+ int nAttr, nGr, n;
+ int *i;
+ std::string *s;
-// nAttr = IOR_Family->getNumberOfAttributes();
-// setNumberOfAttributes(nAttr);
+ nAttr = IOR_Family->getNumberOfAttributes();
+ setNumberOfAttributes(nAttr);
-// convertCorbaArray(i, n, IOR_Family->getAttributesIdentifiers());
-// ASSERT(n == nAttr);
-// setAttributesIdentifiers(i);
+ convertCorbaArray(i, n, IOR_Family->getAttributesIdentifiers());
+ ASSERT(n == nAttr);
+ setAttributesIdentifiers(i);
-// convertCorbaArray(i, n, IOR_Family->getAttributesValues());
-// ASSERT(n == _numberOfAttribute);
-// setAttributesValues(i);
+ convertCorbaArray(i, n, IOR_Family->getAttributesValues());
+ ASSERT(n == _numberOfAttribute);
+ setAttributesValues(i);
-// convertCorbaArray(s, n, IOR_Family->getAttributesDescriptions());
-// ASSERT(n == _numberOfAttribute);
-// setAttributesDescriptions(s);
+ convertCorbaArray(s, n, IOR_Family->getAttributesDescriptions());
+ ASSERT(n == _numberOfAttribute);
+ setAttributesDescriptions(s);
-// nGr = IOR_Family->getNumberOfGroups();
-// setNumberOfGroups(nGr);
+ nGr = IOR_Family->getNumberOfGroups();
+ setNumberOfGroups(nGr);
-// convertCorbaArray(s, n, IOR_Family->getGroupsNames());
-// ASSERT(n == _numberOfAttribute);
-// setGroupsNames(s);
+ convertCorbaArray(s, n, IOR_Family->getGroupsNames());
+ ASSERT(n == _numberOfGroup);
+ setGroupsNames(s);
_complete = false;
if (fillSupport)
SUPPORTClient::fillCopy();
-
+
+ // Get other FAMILY attributes
+
_complete = true;
}
_coord->fillCopy();
_connect->fillCopy();
+ int size = _familyNode.size();
+
+ for (int i = 0; i < size; i++)
+ {
+ FAMILYClient * _fam = dynamic_cast<FAMILYClient *> (_familyNode[i]);
+ ASSERT(_fam);
+
+ _fam->fillCopy();
+ }
+
+ size = _familyCell.size();
+
+ for (int i = 0; i < size; i++)
+ {
+ FAMILYClient * _fam = dynamic_cast<FAMILYClient *> (_familyCell[i]);
+ ASSERT(_fam);
+
+ _fam->fillCopy();
+ }
+
+ size = _familyFace.size();
+
+ for (int i = 0; i < size; i++)
+ {
+ FAMILYClient * _fam = dynamic_cast<FAMILYClient *> (_familyFace[i]);
+ ASSERT(_fam);
+
+ _fam->fillCopy();
+ }
+
+ size = _familyEdge.size();
+
+ for (int i = 0; i < size; i++)
+ {
+ FAMILYClient * _fam = dynamic_cast<FAMILYClient *> (_familyEdge[i]);
+ ASSERT(_fam);
+
+ _fam->fillCopy();
+ }
+
_complete = true;
END_OF("MESHClient::fillCopy()");
SCRUTE(_totalNumberOfElements);
_complete_support = false;
- //Gauss points settings
- _numberOfGaussPoint = new int[_numberOfGeometricType];
- for (int i=0;i<_numberOfGeometricType;i++)
- _numberOfGaussPoint[i] = 1 ;
}
catch( const CORBA::Exception &ex )
{
