MED_Structures.hxx

Go to the documentation of this file.

// Copyright (C) 2007-2026  CEA, EDF, OPEN CASCADE
//
// Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// 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
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
 
#ifndef MED_Structures_HeaderFile
#define MED_Structures_HeaderFile
 
#include "MED_WrapperDef.hxx"
#include "MED_Common.hxx"
#include "MED_Utilities.hxx"
#include "MED_SliceArray.hxx"
 
#include <boost/tuple/tuple.hpp>
 
#ifdef WIN32
#pragma warning(disable:4251)
#endif
 
namespace MED
{
  //---------------------------------------------------------------
  typedef TVector<char> TString;
  typedef SharedPtr<TString> PString;
 
  //---------------------------------------------------------------
  MEDWRAPPER_EXPORT
  std::string
  GetString(TInt theId,
            TInt theStep,
            const TString& theString);
 
  //---------------------------------------------------------------
  MEDWRAPPER_EXPORT
  void
  SetString(TInt theId,
            TInt theStep,
            TString& theString,
            const std::string& theValue);
 
  //---------------------------------------------------------------
  MEDWRAPPER_EXPORT
  void
  SetString(TInt theId,
            TInt theStep,
            TString& theString,
            const TString& theValue);
 
  //---------------------------------------------------------------
  struct MEDWRAPPER_EXPORT TBase
  {
    virtual ~TBase() {}
  };
 
  //---------------------------------------------------------------
  struct MEDWRAPPER_EXPORT TNameInfo: virtual TBase
  {
    TString myName; 
    virtual std::string GetName() const = 0; 
    virtual void SetName(const std::string& theValue) = 0; 
    virtual void SetName(const TString& theValue) = 0; 
  };
 
  //---------------------------------------------------------------
 
  struct MEDWRAPPER_EXPORT TModeSwitchInfo: virtual TBase
  {
    TModeSwitchInfo():
      myModeSwitch(eFULL_INTERLACE)
    {}
 
    TModeSwitchInfo(EModeSwitch theModeSwitch):
      myModeSwitch(theModeSwitch)
    {}
 
    EModeSwitch myModeSwitch; 
    EModeSwitch GetModeSwitch() const { return myModeSwitch; }
  };
 
  //---------------------------------------------------------------
  struct MEDWRAPPER_EXPORT TMeshInfo: virtual TNameInfo
  {
    TInt myDim; 
    TInt GetDim() const { return myDim; } 
 
    TInt mySpaceDim;
    TInt GetSpaceDim() const { return mySpaceDim; }
 
    EMaillage myType; 
    EMaillage GetType() const { return myType; } 
 
    TString myDesc; 
    virtual std::string GetDesc() const = 0; 
    virtual void SetDesc(const std::string& theValue) = 0; 
  };
 
  //---------------------------------------------------------------
  typedef TSlice<TInt> TIntVecSlice;
  typedef TCSlice<TInt> TCIntVecSlice;
  typedef TIntVector TFamAttr;
 
  //---------------------------------------------------------------
  struct MEDWRAPPER_EXPORT TFamilyInfo: virtual TNameInfo
  {
    PMeshInfo myMeshInfo; 
    const PMeshInfo& GetMeshInfo() const { return myMeshInfo; }
 
    TInt myId; 
    TInt GetId() const { return myId; } 
    void SetId(TInt theId) { myId = theId; } 
 
    TInt myNbGroup; 
    TInt GetNbGroup() const { return myNbGroup; }
 
    TString myGroupNames;
    virtual std::string GetGroupName(TInt theId) const = 0;
    virtual void SetGroupName(TInt theId, const std::string& theValue) = 0;
 
    TInt myNbAttr; 
    TInt GetNbAttr() const { return myNbAttr; }
 
    TFamAttr myAttrId;
    TInt GetAttrId(TInt theId) const;
    void SetAttrId(TInt theId, TInt theVal);
 
    TFamAttr myAttrVal;
    TInt GetAttrVal(TInt theId) const;
    void SetAttrVal(TInt theId, TInt theVal);
 
    TString myAttrDesc;
    virtual std::string GetAttrDesc(TInt theId) const = 0;
    virtual void SetAttrDesc(TInt theId, const std::string& theValue) = 0;
  };
 
  //---------------------------------------------------------------
  typedef TIntVector TElemNum;
  typedef SharedPtr<TElemNum> PElemNum;
 
  //---------------------------------------------------------------
  struct MEDWRAPPER_EXPORT TElemInfo: virtual TBase
  {
    PMeshInfo myMeshInfo; 
    const PMeshInfo& GetMeshInfo() const { return myMeshInfo; }
 
    TInt myNbElem; //<! Number of corresponding mesh entities
    TInt GetNbElem() const { return myNbElem; } 
 
    PElemNum myFamNum;
    TInt GetFamNum(TInt theId) const;
    void SetFamNum(TInt theId, TInt theVal);
 
    EBooleen myIsElemNum;
    EBooleen IsElemNum() const { return myIsElemNum; }
 
    EBooleen myIsFamNum;
    EBooleen IsFamNum() const { return myIsFamNum; }
 
    PElemNum myElemNum;
    TInt GetElemNum(TInt theId) const;
    void SetElemNum(TInt theId, TInt theVal);
 
    EBooleen myIsElemNames;
    EBooleen IsElemNames() const { return myIsElemNames; }
 
    PString myElemNames;
    virtual std::string GetElemName(TInt theId) const = 0;
    virtual void SetElemName(TInt theId, const std::string& theValue) = 0;
  };
 
  //---------------------------------------------------------------
  typedef TSlice<TFloat> TFloatVecSlice;
  typedef TCSlice<TFloat> TCFloatVecSlice;
  typedef TFloatVector TNodeCoord;
  typedef SharedPtr<TNodeCoord> PNodeCoord;
  typedef TFloatVecSlice TCoordSlice;
  typedef TCFloatVecSlice TCCoordSlice;
 
  //---------------------------------------------------------------
  struct MEDWRAPPER_EXPORT TNodeInfo:
    virtual TElemInfo,
    virtual TModeSwitchInfo
  {
    PNodeCoord myCoord; 
 
    TCCoordSlice GetCoordSlice(TInt theId) const;
    TCoordSlice GetCoordSlice(TInt theId);
 
    ERepere mySystem; 
    ERepere GetSystem() const { return mySystem; }
    void SetSystem(ERepere theSystem) { mySystem = theSystem; }
 
    TString myCoordNames; 
    virtual std::string GetCoordName(TInt theId) const = 0;
    virtual void SetCoordName(TInt theId, const std::string& theValue) = 0;
 
    TString myCoordUnits; 
    virtual std::string GetCoordUnit(TInt theId) const = 0;
    virtual void SetCoordUnit(TInt theId, const std::string& theValue) = 0;
  };
 
  //---------------------------------------------------------------
  typedef TIntVecSlice TConnSlice;
  typedef TCIntVecSlice TCConnSlice;
 
  //---------------------------------------------------------------
  struct MEDWRAPPER_EXPORT TCellInfo:
    virtual TElemInfo,
    virtual TModeSwitchInfo
  {
    EEntiteMaillage myEntity; 
    EEntiteMaillage GetEntity() const { return myEntity; }
 
    EGeometrieElement myGeom; 
    EGeometrieElement GetGeom() const { return myGeom; }
 
    EConnectivite myConnMode; 
    EConnectivite GetConnMode() const { return myConnMode; }
 
    virtual TInt GetConnDim() const = 0; 
 
    PElemNum myConn; 
 
    TCConnSlice GetConnSlice(TInt theElemId) const;
    TConnSlice GetConnSlice(TInt theElemId);
  };
 
  //---------------------------------------------------------------
  struct MEDWRAPPER_EXPORT TPolygoneInfo:
    virtual TElemInfo
  {
    EEntiteMaillage myEntity; // MED_FACE|MED_MAILLE
    EEntiteMaillage GetEntity() const { return myEntity; }
 
    EGeometrieElement myGeom; // ePOLYGONE
    EGeometrieElement GetGeom() const { return ePOLYGONE; }
 
    EConnectivite myConnMode; // eNOD|eDESC(eDESC not used)
    EConnectivite GetConnMode() const { return myConnMode; }
 
    PElemNum myConn; 
    PElemNum myIndex; 
 
    TInt GetNbConn(TInt theElemId) const;
 
    TCConnSlice GetConnSlice(TInt theElemId) const;
    TConnSlice GetConnSlice(TInt theElemId);
  };
 
  //---------------------------------------------------------------
 
  struct MEDWRAPPER_EXPORT TBallInfo:
    virtual TCellInfo
  {
    TFloatVector myDiameters;
  };
 
  //---------------------------------------------------------------
  typedef TVector<TCConnSlice> TCConnSliceArr;
  typedef TVector<TConnSlice> TConnSliceArr;
 
  //---------------------------------------------------------------
  struct MEDWRAPPER_EXPORT TPolyedreInfo:
    virtual TElemInfo
  {
    EEntiteMaillage myEntity; // MED_FACE|MED_MAILLE
    EEntiteMaillage GetEntity() const { return myEntity; }
 
    EGeometrieElement myGeom; // ePOLYEDRE
    EGeometrieElement GetGeom() const { return ePOLYEDRE; }
 
    EConnectivite myConnMode; // eNOD|eDESC(eDESC not used)
    EConnectivite GetConnMode() const { return myConnMode; }
 
    PElemNum myConn; 
    PElemNum myFaces; 
    PElemNum myIndex; 
 
    TInt GetNbFaces(TInt theElemId) const;
    TInt GetNbNodes(TInt theElemId) const;
 
    TCConnSliceArr GetConnSliceArr(TInt theElemId) const;
    TConnSliceArr GetConnSliceArr(TInt theElemId);
  };
 
  //---------------------------------------------------------------
  struct MEDWRAPPER_EXPORT TFieldInfo:
    virtual TNameInfo
  {
    PMeshInfo myMeshInfo; 
    const PMeshInfo& GetMeshInfo() const { return myMeshInfo; }
 
    ETypeChamp myType; 
    ETypeChamp GetType() const { return myType; }
 
    TInt myNbComp; 
    TInt GetNbComp() const { return myNbComp; }
 
    EBooleen myIsLocal; 
    EBooleen GetIsLocal() const { return myIsLocal; }
 
    TInt myNbRef; 
    TInt GetNbRef() const { return myNbRef; }
 
    TString myCompNames; 
    virtual std::string GetCompName(TInt theId) const = 0;
    virtual void SetCompName(TInt theId, const std::string& theValue) = 0;
 
    TString myUnitNames; 
    virtual std::string GetUnitName(TInt theId) const = 0;
    virtual void SetUnitName(TInt theId, const std::string& theValue) = 0;
  };
 
  //---------------------------------------------------------------
  MEDWRAPPER_EXPORT
  TInt
  GetDimGaussCoord(EGeometrieElement theGeom);
 
  //---------------------------------------------------------------
  MEDWRAPPER_EXPORT
  TInt
  GetNbRefCoord(EGeometrieElement theGeom);
 
  //---------------------------------------------------------------
  typedef TFloatVector TWeight;
 
  //---------------------------------------------------------------
  struct MEDWRAPPER_EXPORT TGaussInfo:
    virtual TNameInfo,
    virtual TModeSwitchInfo
  {
    typedef boost::tuple<EGeometrieElement,std::string> TKey;
    typedef boost::tuple<TKey,TInt> TInfo;
    struct MEDWRAPPER_EXPORT TLess
    {
      bool
      operator()(const TKey& theLeft, const TKey& theRight) const;
 
      bool
      operator()(const TGaussInfo& theLeft, const TGaussInfo& theRight) const;
    };
 
    EGeometrieElement myGeom;
    EGeometrieElement GetGeom() const { return myGeom; }
 
    TNodeCoord myRefCoord;
 
    TCCoordSlice GetRefCoordSlice(TInt theId) const;
    TCoordSlice GetRefCoordSlice(TInt theId);
 
    TNodeCoord myGaussCoord;
 
    TCCoordSlice GetGaussCoordSlice(TInt theId) const;
    TCoordSlice GetGaussCoordSlice(TInt theId);
 
    TWeight myWeight;
 
    TInt GetNbRef() const { return GetNbRefCoord(GetGeom()); }
 
    TInt GetDim() const { return GetDimGaussCoord(GetGeom()); }
 
    TInt GetNbGauss() const { return (TInt)(myGaussCoord.size() / GetDim()); }
  };
 
  //---------------------------------------------------------------
  typedef std::map<EGeometrieElement,PGaussInfo> TGeom2Gauss;
  typedef std::map<EGeometrieElement,TInt> TGeom2NbGauss;
 
  //---------------------------------------------------------------
  struct MEDWRAPPER_EXPORT TTimeStampInfo:
    virtual TBase
  {
    PFieldInfo myFieldInfo; 
    const PFieldInfo& GetFieldInfo() const { return myFieldInfo; }
 
    EEntiteMaillage myEntity;
    EEntiteMaillage GetEntity() const { return myEntity; }
 
    TGeom2Size myGeom2Size;
    const TGeom2Size& GetGeom2Size() const { return myGeom2Size; }
 
    TGeom2NbGauss myGeom2NbGauss; 
    TInt GetNbGauss(EGeometrieElement theGeom) const; 
 
    TInt myNumDt; 
    TInt GetNumDt() const { return myNumDt; } 
 
    TInt myNumOrd; 
    TInt GetNumOrd() const { return myNumOrd; } 
 
    TFloat myDt; 
    TFloat GetDt() const { return myDt; } 
 
    TGeom2Gauss myGeom2Gauss;
    const TGeom2Gauss& GetGeom2Gauss() const { return myGeom2Gauss; }
 
    TString myUnitDt; 
    virtual std::string GetUnitDt() const = 0;
    virtual void SetUnitDt(const std::string& theValue) = 0;
  };
 
  //---------------------------------------------------------------
  struct MEDWRAPPER_EXPORT TProfileInfo:
    virtual TNameInfo
  {
    typedef std::string TKey;
    typedef boost::tuple<TKey,TInt> TInfo;
 
    EModeProfil myMode; 
    EModeProfil GetMode() const { return myMode; }
    void SetMode(EModeProfil theMode) { myMode = theMode; }
 
    PElemNum myElemNum; 
    TInt GetElemNum(TInt theId) const;
    void SetElemNum(TInt theId, TInt theVal);
 
    bool IsPresent() const { return GetName() != ""; }
 
    TInt GetSize() const { return (TInt)myElemNum->size(); }
  };
 
  //---------------------------------------------------------------
  struct MEDWRAPPER_EXPORT TMeshValueBase:
    virtual TModeSwitchInfo
  {
    TInt myNbElem;
    TInt myNbComp;
    TInt myNbGauss;
    TInt myStep;
 
    TMeshValueBase();
 
    void
    Allocate(TInt theNbElem,
             TInt theNbGauss,
             TInt theNbComp,
             EModeSwitch theMode = eFULL_INTERLACE);
 
    size_t
    GetSize() const;
 
    size_t
    GetNbVal() const;
 
    size_t
    GetNbGauss() const;
 
    size_t
    GetStep() const;
 
    virtual
    unsigned char*
    GetValuePtr() = 0;
  };
 
  //---------------------------------------------------------------
  template<class TValueType>
  struct TTMeshValue:
    virtual TMeshValueBase
  {
    typedef TValueType TValue;
    typedef typename TValueType::value_type TElement;
 
    typedef TSlice<TElement> TValueSlice;
    typedef TCSlice<TElement> TCValueSlice;
 
    typedef TVector<TCValueSlice> TCValueSliceArr;
    typedef TVector<TValueSlice> TValueSliceArr;
 
    TValue myValue;
 
    void
    Allocate(TInt theNbElem,
             TInt theNbGauss,
             TInt theNbComp,
             EModeSwitch theMode = eFULL_INTERLACE)
    {
      TMeshValueBase::Allocate(theNbElem, theNbGauss, theNbComp, theMode);
      myValue.resize(theNbElem * this->GetStep());
    }
 
    virtual
    unsigned char*
    GetValuePtr()
    {
      return (unsigned char*)&myValue[0];
    }
 
    virtual
    TElement*
    GetPointer()
    {
      return &myValue[0];
    }
 
    virtual
    const TElement*
    GetPointer() const
    {
      return &myValue[0];
    }
 
    TCValueSliceArr
    GetGaussValueSliceArr(TInt theElemId) const
    {
      TCValueSliceArr aValueSliceArr(myNbGauss);
      if(GetModeSwitch() == eFULL_INTERLACE){
        TInt anId = theElemId * myStep;
        for(TInt aGaussId = 0; aGaussId < myNbGauss; aGaussId++){
          aValueSliceArr[aGaussId] =
            TCValueSlice(myValue, std::slice(anId, myNbComp, 1));
          anId += myNbComp;
        }
      }
      else{
        for(TInt aGaussId = 0; aGaussId < myNbGauss; aGaussId++){
          aValueSliceArr[aGaussId] =
            TCValueSlice(myValue, std::slice(theElemId, myNbComp, myStep));
        }
      }
      return aValueSliceArr;
    }
 
    TValueSliceArr
    GetGaussValueSliceArr(TInt theElemId)
    {
      TValueSliceArr aValueSliceArr(myNbGauss);
      if(GetModeSwitch() == eFULL_INTERLACE){
        TInt anId = theElemId*myStep;
        for(TInt aGaussId = 0; aGaussId < myNbGauss; aGaussId++){
          aValueSliceArr[aGaussId] =
            TValueSlice(myValue, std::slice(anId, myNbComp, 1));
          anId += myNbComp;
        }
      }
      else{
        for(TInt aGaussId = 0; aGaussId < myNbGauss; aGaussId++){
          aValueSliceArr[aGaussId] =
            TValueSlice(myValue, std::slice(theElemId, myNbComp, myStep));
        }
      }
      return aValueSliceArr;
    }
 
    TCValueSliceArr
    GetCompValueSliceArr(TInt theElemId) const
    {
      TCValueSliceArr aValueSliceArr(myNbComp);
      if(GetModeSwitch() == eFULL_INTERLACE){
        TInt anId = theElemId*myStep;
        for(TInt aCompId = 0; aCompId < myNbComp; aCompId++){
          aValueSliceArr[aCompId] =
            TCValueSlice(myValue, std::slice(anId, myNbGauss, myNbComp));
          anId += 1;
        }
      }
      else{
        for(TInt aCompId = 0; aCompId < myNbComp; aCompId++){
          aValueSliceArr[aCompId] =
            TCValueSlice(myValue, std::slice(theElemId, myNbGauss, myStep));
        }
      }
      return aValueSliceArr;
    }
 
    TValueSliceArr
    GetCompValueSliceArr(TInt theElemId)
    {
      if(GetModeSwitch() == eFULL_INTERLACE){
        TValueSliceArr aValueSliceArr(myNbComp);
        TInt anId = theElemId*myStep;
        for(TInt aCompId = 0; aCompId < myNbComp; aCompId++){
          aValueSliceArr[aCompId] =
            TValueSlice(myValue, std::slice(anId, myNbGauss, myNbComp));
          anId += 1;
        }
        return aValueSliceArr;
      }
      else{
        TValueSliceArr aValueSliceArr(myNbGauss);
        for(TInt aGaussId = 0; aGaussId < myNbGauss; aGaussId++){
          aValueSliceArr[aGaussId] =
            TValueSlice(myValue,std::slice(theElemId, myNbComp, myStep));
        }
        return aValueSliceArr;
      }
    }
  };
 
  //---------------------------------------------------------------
  typedef TTMeshValue<TFloatVector> TFloatMeshValue;
  typedef TTMeshValue<TIntVector> TIntMeshValue;
 
  //---------------------------------------------------------------
  // Backward compatibility declarations
  typedef TFloatVector TValue;
  typedef TSlice<TFloat> TValueSlice;
  typedef TCSlice<TFloat> TCValueSlice;
 
  typedef TVector<TCValueSlice> TCValueSliceArr;
  typedef TVector<TValueSlice> TValueSliceArr;
 
  typedef TFloatMeshValue TMeshValue;
  typedef std::map<EGeometrieElement,TMeshValue> TGeom2Value;
 
  //---------------------------------------------------------------
  typedef std::map<EGeometrieElement,PProfileInfo> TGeom2Profile;
  typedef std::set<EGeometrieElement> TGeom;
 
  //---------------------------------------------------------------
  struct MEDWRAPPER_EXPORT TTimeStampValueBase:
    virtual TModeSwitchInfo
  {
    PTimeStampInfo myTimeStampInfo;
    const PTimeStampInfo& GetTimeStampInfo() const { return myTimeStampInfo; }
 
    TGeomSet myGeomSet;
    const TGeomSet& GetGeomSet() const { return myGeomSet; }
 
    TGeom2Profile myGeom2Profile;
    const TGeom2Profile& GetGeom2Profile() const { return myGeom2Profile; }
 
    virtual
    ETypeChamp
    GetTypeChamp() const = 0;
 
    virtual
    void
    AllocateValue(EGeometrieElement theGeom,
                  TInt theNbElem,
                  TInt theNbGauss,
                  TInt theNbComp,
                  EModeSwitch theMode = eFULL_INTERLACE) = 0;
 
    virtual
    size_t
    GetValueSize(EGeometrieElement theGeom) const = 0;
 
    virtual
    size_t
    GetNbVal(EGeometrieElement theGeom) const = 0;
 
    virtual
    size_t
    GetNbGauss(EGeometrieElement theGeom) const = 0;
 
    virtual
    unsigned char*
    GetValuePtr(EGeometrieElement theGeom) = 0;
  };
 
  //---------------------------------------------------------------
  template<class TMeshValueType>
  struct TTimeStampValue:
    virtual TTimeStampValueBase
  {
    typedef TMeshValueType TTMeshValue;
    typedef SharedPtr<TMeshValueType> PTMeshValue;
    typedef typename TMeshValueType::TElement TElement;
    typedef std::map<EGeometrieElement, PTMeshValue> TTGeom2Value;
 
    ETypeChamp myTypeChamp; //<! Keeps type of the champ
 
    virtual
    ETypeChamp
    GetTypeChamp() const
    {
      return myTypeChamp;
    }
 
    TTGeom2Value myGeom2Value;
 
    const TTGeom2Value&
    GetGeom2Value() const
    {
      return myGeom2Value;
    }
 
    const PTMeshValue&
    GetMeshValuePtr(EGeometrieElement theGeom) const
    {
      typename TTGeom2Value::const_iterator anIter = myGeom2Value.find(theGeom);
      if(anIter == myGeom2Value.end())
        EXCEPTION(std::runtime_error,"TTimeStampValue::GetMeshValuePtr - myGeom2Value.find(theGeom) fails");
      return anIter->second;
    }
 
    PTMeshValue&
    GetMeshValuePtr(EGeometrieElement theGeom)
    {
      myGeomSet.insert(theGeom);
      if(myGeom2Value.find(theGeom) == myGeom2Value.end()){
        myGeom2Value[theGeom] = PTMeshValue(new TTMeshValue());
        return myGeom2Value[theGeom];
      }
      return myGeom2Value[theGeom];
    }
 
    const TTMeshValue&
    GetMeshValue(EGeometrieElement theGeom) const
    {
      return *(this->GetMeshValuePtr(theGeom));
    }
 
    TTMeshValue&
    GetMeshValue(EGeometrieElement theGeom)
    {
      return *(this->GetMeshValuePtr(theGeom));
    }
  };
 
  //---------------------------------------------------------------
  typedef TTimeStampValue<TFloatMeshValue> TFloatTimeStampValue;
  typedef SharedPtr<TFloatTimeStampValue> PFloatTimeStampValue;
 
  PFloatTimeStampValue MEDWRAPPER_EXPORT
  CastToFloatTimeStampValue(const PTimeStampValueBase& theTimeStampValue);
 
  typedef TTimeStampValue<TIntMeshValue> TIntTimeStampValue;
  typedef SharedPtr<TIntTimeStampValue> PIntTimeStampValue;
 
  PIntTimeStampValue MEDWRAPPER_EXPORT
  CastToIntTimeStampValue(const PTimeStampValueBase& theTimeStampValue);
 
  //---------------------------------------------------------------
  template<class TMeshValueTypeFrom, class TMeshValueTypeTo>
  void
  CopyTimeStampValue(SharedPtr<TTimeStampValue<TMeshValueTypeFrom> > theTimeStampValueFrom,
                     SharedPtr<TTimeStampValue<TMeshValueTypeTo> > theTimeStampValueTo)
  {
    typedef TTimeStampValue<TMeshValueTypeFrom> TimeStampValueTypeFrom;
    typedef TTimeStampValue<TMeshValueTypeTo> TimeStampValueTypeTo;
    typedef typename TMeshValueTypeTo::TElement TElementTo;
 
    typename TimeStampValueTypeFrom::TTGeom2Value& aGeom2Value = theTimeStampValueFrom->myGeom2Value;
    typename TimeStampValueTypeFrom::TTGeom2Value::const_iterator anIter = aGeom2Value.begin();
    for(; anIter != aGeom2Value.end(); anIter++){
      const EGeometrieElement& aGeom = anIter->first;
      const typename TimeStampValueTypeFrom::TTMeshValue& aMeshValue = *anIter->second;
      typename TimeStampValueTypeTo::TTMeshValue& aMeshValue2 = theTimeStampValueTo->GetMeshValue(aGeom);
      aMeshValue2.Allocate(aMeshValue.myNbElem,
                           aMeshValue.myNbGauss,
                           aMeshValue.myNbComp,
                           aMeshValue.myModeSwitch);
      const typename TimeStampValueTypeFrom::TTMeshValue::TValue& aValue = aMeshValue.myValue;
      typename TimeStampValueTypeTo::TTMeshValue::TValue& aValue2 = aMeshValue2.myValue;
      TInt aSize = aValue.size();
      for(TInt anId = 0; anId < aSize; anId++)
        aValue2[anId] = TElementTo(aValue[anId]);
    }
  }
 
  //---------------------------------------------------------------
  template<class TMeshValueType>
  void
  CopyTimeStampValue(SharedPtr<TTimeStampValue<TMeshValueType> > theTimeStampValueFrom,
                     SharedPtr<TTimeStampValue<TMeshValueType> > theTimeStampValueTo)
  {
    typedef TTimeStampValue<TMeshValueType> TimeStampValueType;
    typename TimeStampValueType::TTGeom2Value& aGeom2Value = theTimeStampValueFrom->myGeom2Value;
    typename TimeStampValueType::TTGeom2Value::const_iterator anIter = aGeom2Value.begin();
    for(; anIter != aGeom2Value.end(); anIter++){
      const EGeometrieElement& aGeom = anIter->first;
      const typename TimeStampValueType::TTMeshValue& aMeshValue = *anIter->second;
      typename TimeStampValueType::TTMeshValue& aMeshValue2 = theTimeStampValueTo->GetMeshValue(aGeom);
      aMeshValue2 = aMeshValue;
    }
  }
 
  //---------------------------------------------------------------
  inline
  void
  CopyTimeStampValueBase(const PTimeStampValueBase& theValueFrom,
                         const PTimeStampValueBase& theValueTo)
  {
    if(theValueFrom->GetTypeChamp() == theValueTo->GetTypeChamp()){
      if(theValueFrom->GetTypeChamp() == eFLOAT64)
        CopyTimeStampValue<TFloatMeshValue>(theValueFrom, theValueTo);
      else if(theValueFrom->GetTypeChamp() == eINT)
        CopyTimeStampValue<TIntMeshValue>(theValueFrom, theValueTo);
    }else{
      if(theValueFrom->GetTypeChamp() == eFLOAT64 && theValueTo->GetTypeChamp() == eINT)
        CopyTimeStampValue<TFloatMeshValue, TIntMeshValue>(theValueFrom, theValueTo);
      else if(theValueFrom->GetTypeChamp() == eINT && theValueTo->GetTypeChamp() == eFLOAT64)
        CopyTimeStampValue<TIntMeshValue, TFloatMeshValue>(theValueFrom, theValueTo);
    }
  }
 
  //---------------------------------------------------------------
  // Backward compatibility declarations
  typedef TFloatTimeStampValue TTimeStampVal;
  typedef PFloatTimeStampValue PTimeStampVal;
 
  //---------------------------------------------------------------
  typedef std::map<TInt,TFloatVector> TIndexes;
  typedef std::map<TInt,TString> TNames;
 
  //---------------------------------------------------------------
  struct MEDWRAPPER_EXPORT TGrilleInfo:
    virtual TModeSwitchInfo
  {
    PMeshInfo myMeshInfo;
    const PMeshInfo& GetMeshInfo() const { return myMeshInfo; }
 
    TNodeCoord myCoord; 
    const TNodeCoord& GetNodeCoord() const;
    TNodeCoord& GetNodeCoord();
    TNodeCoord GetCoord(TInt theId);
    TIntVector GetConn(TInt theId, const bool isSub=false);
 
    EGrilleType myGrilleType; 
    const EGrilleType& GetGrilleType() const;
    EGrilleType GetGrilleType();
    void SetGrilleType(EGrilleType theGrilleType);
 
    TString myCoordNames; 
    virtual std::string GetCoordName(TInt theId) const = 0 ;
    virtual void SetCoordName(TInt theId, const std::string& theValue) = 0;
 
    TString myCoordUnits; 
    virtual std::string GetCoordUnit(TInt theId) const = 0;
    virtual void SetCoordUnit(TInt theId, const std::string& theValue) = 0;
 
    TIndexes myIndixes;
    const TIndexes& GetMapOfIndexes() const ;
    TIndexes& GetMapOfIndexes();
    const TFloatVector& GetIndexes(TInt theAxisNumber) const;
    TFloatVector& GetIndexes(TInt theAxisNumber);
    TInt GetNbIndexes(TInt theAxisNumber);
 
    TInt GetNbNodes();
    TInt GetNbCells();
    TInt GetNbSubCells();
    EGeometrieElement GetGeom();
    EGeometrieElement GetSubGeom();
    EEntiteMaillage GetEntity();
    EEntiteMaillage GetSubEntity();
 
    TIntVector myGrilleStructure;
    const TIntVector& GetGrilleStructure() const;
    TIntVector GetGrilleStructure();
    void SetGrilleStructure(TInt theAxis,TInt theNb);
 
    TElemNum myFamNum;
    TInt GetFamNum(TInt theId) const;
    void SetFamNum(TInt theId, TInt theVal);
 
    TElemNum myFamSubNum;
    TInt GetFamSubNum(TInt theId) const;
    void SetFamSubNum(TInt theId, TInt theVal);
 
    TElemNum myFamNumNode;
    TInt GetFamNumNode(TInt theId) const;
    void SetFamNumNode(TInt theId, TInt theVal);
  };
}
 
#endif // MED_Structures_HeaderFile