From: apo <apo@opencascade.com>
Date: Fri, 26 Aug 2005 08:28:05 +0000 (+0000)
Subject: To customize VISU::ScalarMap_i::Build method
X-Git-Tag: BR-D5-38-2003_D2005-12-09~97
X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=37704cb67b2656b6bd1d307def0686e515f0b484;p=modules%2Fvisu.git

To customize VISU::ScalarMap_i::Build method
---

diff --git a/src/CONVERTOR/VISU_Convertor.hxx b/src/CONVERTOR/VISU_Convertor.hxx
index ab518de3..2426356d 100644
--- a/src/CONVERTOR/VISU_Convertor.hxx
+++ b/src/CONVERTOR/VISU_Convertor.hxx
@@ -39,6 +39,8 @@
 #include "MED_SharedPtr.hxx"
 #include "MED_Vector.hxx"
 
+#include <vtkSystemIncludes.h>
+
 class vtkUnstructuredGrid;
 
 namespace VISU
@@ -83,6 +85,12 @@ namespace VISU
   struct TValForTime;
   typedef SharedPtr<TValForTime> PValForTime;
 
+  struct TMeshValForTime;
+  typedef SharedPtr<TMeshValForTime> PMeshValForTime;
+
+  struct TGaussPtsValForTime;
+  typedef SharedPtr<TGaussPtsValForTime> PGaussPtsValForTime;
+
   typedef std::string TName;
 
   typedef TVector<TName> TNames;
@@ -152,11 +160,14 @@ namespace VISU
   struct TGaussSubMesh: virtual TBaseStructure
   {
     PSubProfile mySubProfile;
-    PGauss myGauss;
   };
 
   
   //---------------------------------------------------------------
+  typedef vtkIdType TCellID;
+  typedef vtkIdType TLocalPntID;
+  typedef std::pair<TCellID,TLocalPntID> TGaussPointID;
+
   struct TGaussMesh: virtual TBaseStructure
   {};
 
@@ -205,7 +216,7 @@ namespace VISU
 
 
   //---------------------------------------------------------------
-  typedef std::map<int,PValForTime> TValField;
+  typedef std::map<int,PGaussPtsValForTime> TValField;
 
   struct TField: virtual TIntId
   {
@@ -231,11 +242,23 @@ namespace VISU
     TName myMeshName;
     TName myFieldName;
     TTime myTime;
-    
+  };
+
+
+  //---------------------------------------------------------------
+  struct TMeshValForTime: virtual TValForTime
+  {
     PProfile myProfile;
+  };
+
+
+  struct TGaussPtsValForTime: virtual TValForTime
+  {
     PGaussMesh myGaussMesh;
   };
 
+
+  //---------------------------------------------------------------
   PFamily
   FindFamily(VISU::PMesh theMesh, 
 	     const std::string& theFamilyName);
@@ -315,6 +338,13 @@ public:
 		     const std::string& theFieldName,
 		     int theStampsNum) = 0;
    
+  virtual
+  TOutput* 
+  GetGaussPointsOnMesh(const std::string& theMeshName, 
+		       const VISU::TEntity& theEntity,
+		       const std::string& theFieldName,
+		       int theStampsNum) = 0;
+   
   virtual 
   float
   GetTimeStampSize(const std::string& theMeshName, 
diff --git a/src/CONVERTOR/VISU_Convertor_impl.cxx b/src/CONVERTOR/VISU_Convertor_impl.cxx
index 1abe7336..4f96c751 100644
--- a/src/CONVERTOR/VISU_Convertor_impl.cxx
+++ b/src/CONVERTOR/VISU_Convertor_impl.cxx
@@ -57,7 +57,7 @@ static float ERR_SIZE_CALC = 1.00;
 static int MYVTKDEBUG = 0;
 
 #ifdef _DEBUG_
-static int MYDEBUG = 0;
+static int MYDEBUG = 1;
 static int MYDEBUGWITHFILES = 0;
 #else
 static int MYDEBUG = 0;
@@ -213,18 +213,29 @@ namespace VISU
     myStatus(eNone)
   {}
   
+  TGaussPointID
+  TGaussSubMeshImpl
+  ::GetObjID(vtkIdType theID) const
+  {
+    TCellID aCellID = theID / myGauss->myNbPoints;
+    TLocalPntID aLocalPntID = theID % myGauss->myNbPoints;
+    
+    return TGaussPointID(aCellID,aLocalPntID);
+  }
 
   //---------------------------------------------------------------
   bool
   operator<(const PGaussSubMesh& theLeft, const PGaussSubMesh& theRight)
   {
-    PGaussImpl aLeft(theLeft->myGauss), aRight(theRight->myGauss);
+    PGaussSubMeshImpl aLeft(theLeft), aRight(theRight);
+    const PGaussImpl& aGaussLeft = aLeft->myGauss;
+    const PGaussImpl& aGaussRight = aRight->myGauss;
 
-    if(aLeft->myGeom != aRight->myGeom)
-      return aLeft->myGeom < aRight->myGeom;
+    if(aGaussLeft->myGeom != aGaussRight->myGeom)
+      return aGaussLeft->myGeom < aGaussRight->myGeom;
 
-    if(aLeft->myName != aRight->myName)
-      return aLeft->myName < aRight->myName;
+    if(aGaussLeft->myName != aGaussRight->myName)
+      return aGaussLeft->myName < aGaussRight->myName;
 
     return theLeft->mySubProfile < theRight->mySubProfile;
   }
@@ -303,7 +314,7 @@ namespace VISU
   ::GetCompValueSliceArr(vtkIdType theElemId) const
   {
     TCValueSliceArr aValueSliceArr(myNbComp);
-    vtkIdType anId = theElemId*myStep;
+    vtkIdType anId = theElemId;
     for(vtkIdType aCompId = 0; aCompId < myNbComp; aCompId++){
       aValueSliceArr[aCompId] =
 	TCValueSlice(myValue,std::slice(anId,myNbGauss,myNbGauss));
@@ -349,12 +360,18 @@ namespace VISU
   TValForTimeImpl
   ::GetNbGauss(vtkIdType theGeom) const
   {
-    PGaussMeshImpl aGaussMesh = myGaussMesh;
-    if(aGaussMesh){
+    return myNbGauss;
+  }
+  
+  int
+  TGaussPtsValForTimeImpl
+  ::GetNbGauss(vtkIdType theGeom) const
+  {
+    if(PGaussMeshImpl aGaussMesh = myGaussMesh){
       const TGeom2GaussSubMesh& aGeom2GaussSubMesh = aGaussMesh->myGeom2GaussSubMesh;
       TGeom2GaussSubMesh::const_iterator anIter = aGeom2GaussSubMesh.find(theGeom);
       if(anIter != aGeom2GaussSubMesh.end()){
-	PGaussSubMesh aGaussSubMesh = anIter->second;
+	PGaussSubMeshImpl aGaussSubMesh = anIter->second;
 	PGaussImpl aGauss = aGaussSubMesh->myGauss;
 	return aGauss->myNbPoints;
       }
@@ -938,7 +955,7 @@ namespace
   void 
   GetTimeStampOnGaussMesh(const TVTKSource& theSource,
 			  const PFieldImpl& theField, 
-			  const PValForTimeImpl& theValForTime)
+			  const PGaussPtsValForTimeImpl& theValForTime)
   {
     int aNbTuples = theSource->GetNumberOfPoints();
     std::string aFieldName = GenerateFieldName(theField,theValForTime);
@@ -1320,16 +1337,17 @@ VISU_Convertor_impl
   PMeshImpl aMesh = boost::get<0>(aFindTimeStamp);
   PMeshOnEntityImpl aMeshOnEntity = boost::get<1>(aFindTimeStamp);
   PMeshOnEntityImpl aVTKMeshOnEntity = boost::get<2>(aFindTimeStamp);
-  PValForTimeImpl aValForTime = boost::get<4>(aFindTimeStamp);
+  PGaussPtsValForTimeImpl aValForTime = boost::get<4>(aFindTimeStamp);
   PFieldImpl aField = boost::get<3>(aFindTimeStamp);
 
   //Main part of code
-  const TVTKSource& aSource = aValForTime->GetSource();
+  TSource& aMeshSource = aValForTime->myMeshSource;
+  const TVTKSource& aSource = aMeshSource.GetSource();
 #ifndef _DEXCEPT_
   try{
 #endif
-    if(!aValForTime->myIsVTKDone){
-      LoadFieldOnMesh(aMesh,aMeshOnEntity,aField,aValForTime);
+    if(!aMeshSource.myIsVTKDone){
+      LoadValForTimeOnMesh(aMesh,aMeshOnEntity,aField,aValForTime);
 
       try{
 	LoadMeshOnEntity(aVTKMeshOnEntity);
@@ -1344,24 +1362,92 @@ VISU_Convertor_impl
       GetMeshOnEntity(aVTKMeshOnEntity->myMeshName,aVTKMeshOnEntity->myEntity);
       
       PProfileImpl aProfile = aValForTime->myProfile;
+      GetMeshOnProfile(aMesh,aVTKMeshOnEntity,aProfile);
+      
+      const TVTKAppendFilter& anAppendFilter = aProfile->GetFilter();
+      aSource->ShallowCopy(anAppendFilter->GetOutput());
+      GetTimeStampOnProfile(aSource,aField,aValForTime);
+
+      aMeshSource.myIsVTKDone = true;
+
+      if(MYDEBUGWITHFILES){
+	string aMeshName = QString(theMeshName.c_str()).simplifyWhiteSpace().latin1();
+	string aFieldName = QString(theFieldName.c_str()).simplifyWhiteSpace().latin1();
+	string aPrefix = string("/users/")+getenv("USER")+"/"+getenv("USER")+"-";
+	string aFileName = aPrefix + aMeshName + dtos("-%d-",int(theEntity)) + 
+	  aFieldName + dtos("-%d",theStampsNum) + "-Conv.vtk";
+	VISU::WriteToFile(aSource.GetPointer(),aFileName);
+      }
+      if(MYVTKDEBUG){
+	GetTimeStampSize(theMeshName,theEntity,theFieldName,theStampsNum);
+	aSource->Update();
+	if(theEntity == VISU::NODE_ENTITY)
+	  BEGMSG(MYVTKDEBUG,"GetPointData() = "<<float(aSource->GetPointData()->GetActualMemorySize()*1000)<<endl);
+	else
+	  BEGMSG(MYVTKDEBUG,"GetCellData() = "<<float(aSource->GetCellData()->GetActualMemorySize()*1000)<<endl);
+	BEGMSG(MYVTKDEBUG,"GetActualMemorySize() = "<<float(aSource->GetActualMemorySize()*1000)<<endl);
+      }
+    }
+#ifndef _DEXCEPT_
+  }catch(std::exception& exc){
+    throw;
+  }catch(...){
+    throw;
+  }
+#endif
+
+  return aSource.GetPointer();
+}
+
+
+//---------------------------------------------------------------
+VISU_Convertor::TOutput* 
+VISU_Convertor_impl
+::GetGaussPointsOnMesh(const string& theMeshName, 
+		       const VISU::TEntity& theEntity,
+		       const string& theFieldName,
+		       int theStampsNum)
+{
+  INITMSG(MYDEBUG,"GetGaussPointsOnMesh"<<
+	  "; theMeshName = '"<<theMeshName<<"'"<<
+	  "; theEntity = "<<theEntity<<
+	  "; theFieldName = '"<<theFieldName<<"'"<<
+	  "; theStampsNum = "<<theStampsNum<<
+	  endl);
+
+  //Cheching possibility do the query
+  TFindTimeStamp aFindTimeStamp = FindTimeStamp(theMeshName,
+						theEntity,
+						theFieldName,
+						theStampsNum);
+  
+  PMeshImpl aMesh = boost::get<0>(aFindTimeStamp);
+  PMeshOnEntityImpl aMeshOnEntity = boost::get<1>(aFindTimeStamp);
+  PMeshOnEntityImpl aVTKMeshOnEntity = aMeshOnEntity;
+  PGaussPtsValForTimeImpl aValForTime = boost::get<4>(aFindTimeStamp);
+  PFieldImpl aField = boost::get<3>(aFindTimeStamp);
+
+  //Main part of code
+  TSource& aGaussPtsSource = aValForTime->myGaussPtsSource;
+  const TVTKSource& aSource = aGaussPtsSource.GetSource();
+#ifndef _DEXCEPT_
+  try{
+#endif
+    if(!aGaussPtsSource.myIsVTKDone){
+      LoadValForTimeOnGaussPts(aMesh,aMeshOnEntity,aField,aValForTime);
+      
+      GetMeshOnEntity(aVTKMeshOnEntity->myMeshName,aVTKMeshOnEntity->myEntity);
+      
       PGaussMeshImpl aGaussMesh = aValForTime->myGaussMesh;
       INITMSG(MYDEBUG,"aGaussMesh = "<<bool(aGaussMesh)<<endl);
-      if(!aGaussMesh){
-	GetMeshOnProfile(aMesh,aVTKMeshOnEntity,aProfile);
-     
-	const TVTKAppendFilter& anAppendFilter = aProfile->GetFilter();
-	aSource->ShallowCopy(anAppendFilter->GetOutput());
-	GetTimeStampOnProfile(aSource,aField,aValForTime);
-      }else{
-	const TGeom2GaussSubMesh& aGeom2GaussSubMesh = aGaussMesh->myGeom2GaussSubMesh;
-	GetGaussMesh(aMesh,aVTKMeshOnEntity,aGaussMesh);
-     
-	const TVTKAppendFilter& anAppendFilter = aGaussMesh->GetFilter();
-	aSource->ShallowCopy(anAppendFilter->GetOutput());
-	GetTimeStampOnGaussMesh(aSource,aField,aValForTime);
-      }
+      const TGeom2GaussSubMesh& aGeom2GaussSubMesh = aGaussMesh->myGeom2GaussSubMesh;
+      GetGaussMesh(aMesh,aVTKMeshOnEntity,aGaussMesh);
+      
+      const TVTKAppendFilter& anAppendFilter = aGaussMesh->GetFilter();
+      aSource->ShallowCopy(anAppendFilter->GetOutput());
+      GetTimeStampOnGaussMesh(aSource,aField,aValForTime);
 
-      aValForTime->myIsVTKDone = true;
+      aGaussPtsSource.myIsVTKDone = true;
 
       if(MYDEBUGWITHFILES){
 	string aMeshName = QString(theMeshName.c_str()).simplifyWhiteSpace().latin1();
@@ -1653,7 +1739,7 @@ VISU_Convertor_impl
   PMeshImpl aMesh = boost::get<0>(aFindField);
   PMeshOnEntityImpl aMeshOnEntity = boost::get<1>(aFindField);
   PMeshOnEntityImpl aVTKMeshOnEntity = boost::get<2>(aFindField);
-  PValForTimeImpl aValForTime = aValFieldIter->second;
+  PGaussPtsValForTimeImpl aValForTime = aValFieldIter->second;
 
   return TFindTimeStamp(aMesh,
 			aMeshOnEntity,
diff --git a/src/CONVERTOR/VISU_Convertor_impl.hxx b/src/CONVERTOR/VISU_Convertor_impl.hxx
index ae52155e..1bb1f443 100644
--- a/src/CONVERTOR/VISU_Convertor_impl.hxx
+++ b/src/CONVERTOR/VISU_Convertor_impl.hxx
@@ -9,8 +9,6 @@
 #ifndef VISU_Convertor_impl_HeaderFile
 #define VISU_Convertor_impl_HeaderFile
 
-#include <vtkSystemIncludes.h>
-
 #include <vtkSmartPointer.h>
 
 #include <boost/tuple/tuple.hpp>
@@ -195,14 +193,12 @@ namespace VISU
     TGaussSubMeshImpl();
 
     virtual
-    vtkIdType
-    GetObjID(vtkIdType theID) const
-    {
-      return theID;
-    }
+    TGaussPointID
+    GetObjID(vtkIdType theID) const;
     
-    TPointCoords myPointCoords;
+    PGaussImpl myGauss;
     ESubMeshStatus myStatus;
+    TPointCoords myPointCoords;
   };
   typedef SharedPtr<TGaussSubMeshImpl> PGaussSubMeshImpl;
 
@@ -300,7 +296,7 @@ namespace VISU
   //---------------------------------------------------------------
   typedef std::map<vtkIdType,TMeshValue> TGeom2Value;
 
-  struct TValForTimeImpl: virtual TValForTime, virtual TSource
+  struct TValForTimeImpl: virtual TValForTime
   {
     TGeom2Value myGeom2Value;
 
@@ -312,11 +308,33 @@ namespace VISU
 
     int myNbGauss;
 
+    virtual
     int
     GetNbGauss(vtkIdType theGeom) const;
   };
   typedef SharedPtr<TValForTimeImpl> PValForTimeImpl;
 
+
+  //---------------------------------------------------------------
+  struct TMeshValForTimeImpl: virtual TMeshValForTime, virtual TValForTimeImpl
+  {
+    TSource myMeshSource;
+  };
+
+
+  //---------------------------------------------------------------
+  struct TGaussPtsValForTimeImpl: virtual TGaussPtsValForTime, virtual TMeshValForTimeImpl
+  {
+    TSource myGaussPtsSource;
+
+    virtual
+    int
+    GetNbGauss(vtkIdType theGeom) const;
+  };
+  typedef SharedPtr<TGaussPtsValForTimeImpl> PGaussPtsValForTimeImpl;
+
+
+  //---------------------------------------------------------------
   vtkIdType
   VTKGeom2NbNodes(vtkIdType theGeom);
 }
@@ -393,6 +411,13 @@ public:
 		     const std::string& theFieldName,
 		     int theStampsNum);
 
+  virtual
+  TOutput* 
+  GetGaussPointsOnMesh(const std::string& theMeshName, 
+		       const VISU::TEntity& theEntity,
+		       const std::string& theFieldName,
+		       int theStampsNum);
+
 protected:
   VISU::PMeshImpl 
   FindMesh(const std::string& theMeshName);
@@ -421,7 +446,7 @@ protected:
 		       VISU::PMeshOnEntityImpl,
 		       VISU::PMeshOnEntityImpl,
 		       VISU::PFieldImpl,
-		       VISU::PValForTimeImpl> TFindTimeStamp;
+		       VISU::PGaussPtsValForTimeImpl> TFindTimeStamp;
   TFindTimeStamp
   FindTimeStamp(const std::string& theMeshName, 
 		const VISU::TEntity& theEntity, 
@@ -441,10 +466,17 @@ protected:
 
   virtual 
   int
-  LoadFieldOnMesh(VISU::PMeshImpl theMesh, 
-		  VISU::PMeshOnEntityImpl theMeshOnEntity, 
-		  VISU::PFieldImpl theField, 
-		  VISU::PValForTimeImpl theValForTime) = 0;
+  LoadValForTimeOnMesh(VISU::PMeshImpl theMesh, 
+		       VISU::PMeshOnEntityImpl theMeshOnEntity, 
+		       VISU::PFieldImpl theField, 
+		       VISU::PValForTimeImpl theValForTime) = 0;
+
+  virtual 
+  int
+  LoadValForTimeOnGaussPts(VISU::PMeshImpl theMesh, 
+			   VISU::PMeshOnEntityImpl theMeshOnEntity, 
+			   VISU::PFieldImpl theField, 
+			   VISU::PValForTimeImpl theValForTime) = 0;
 };
 
 #endif
diff --git a/src/CONVERTOR/VISU_MedConvertor.cxx b/src/CONVERTOR/VISU_MedConvertor.cxx
index 358bad43..f0ec57c0 100644
--- a/src/CONVERTOR/VISU_MedConvertor.cxx
+++ b/src/CONVERTOR/VISU_MedConvertor.cxx
@@ -47,7 +47,7 @@ using MED::TFloat;
 using MED::EBooleen;
 
 #ifdef _DEBUG_
-static int MYDEBUG = 0;
+static int MYDEBUG = 1;
 static int MYVALUEDEBUG = 0;
 static int MY_FAMILY_DEBUG = 0;
 static int MY_GROUP_DEBUG = 0;
@@ -725,6 +725,21 @@ namespace
     }
   }
 
+  TGaussPointID
+  TMEDGaussSubMesh
+  ::GetObjID(vtkIdType theID) const
+  {
+    TCellID aCellID = theID / myGauss->myNbPoints;
+    TLocalPntID aLocalPntID = theID % myGauss->myNbPoints;
+    
+    if(myIsElemNum)
+      aCellID = myElemNum[theID];
+    else
+      aCellID = theID;
+
+    return TGaussPointID(aCellID,aLocalPntID);
+  }
+  
 }
 
 
@@ -880,15 +895,32 @@ VISU_MedConvertor
 //---------------------------------------------------------------
 int
 VISU_MedConvertor
-::LoadFieldOnMesh(VISU::PMeshImpl theMesh, 
-		  VISU::PMeshOnEntityImpl theMeshOnEntity, 
-		  VISU::PFieldImpl theField, 
-		  VISU::PValForTimeImpl theValForTime)
+::LoadValForTimeOnMesh(VISU::PMeshImpl theMesh, 
+		       VISU::PMeshOnEntityImpl theMeshOnEntity, 
+		       VISU::PFieldImpl theField, 
+		       VISU::PValForTimeImpl theValForTime)
 {
   MED::PWrapper aMed = MED::CrWrapper(myFileInfo.absFilePath().latin1());
   int isPointsUpdated = LoadPoints(aMed,theMesh);
   int isCellsOnEntityUpdated = LoadCellsOnEntity(aMed,theMesh,theMeshOnEntity);
-  int isFieldUpdated = LoadField(aMed,theMesh,theMeshOnEntity,theField,theValForTime);
+  int isFieldUpdated = LoadValForTimeOnMesh(aMed,theMesh,theMeshOnEntity,theField,theValForTime);
+  
+  return (isPointsUpdated || isCellsOnEntityUpdated || isFieldUpdated);
+}
+
+
+//---------------------------------------------------------------
+int
+VISU_MedConvertor
+::LoadValForTimeOnGaussPts(VISU::PMeshImpl theMesh, 
+			   VISU::PMeshOnEntityImpl theMeshOnEntity, 
+			   VISU::PFieldImpl theField, 
+			   VISU::PValForTimeImpl theValForTime)
+{
+  MED::PWrapper aMed = MED::CrWrapper(myFileInfo.absFilePath().latin1());
+  int isPointsUpdated = LoadPoints(aMed,theMesh);
+  int isCellsOnEntityUpdated = LoadCellsOnEntity(aMed,theMesh,theMeshOnEntity);
+  int isFieldUpdated = LoadValForTimeOnGaussPts(aMed,theMesh,theMeshOnEntity,theField,theValForTime);
   
   return (isPointsUpdated || isCellsOnEntityUpdated || isFieldUpdated);
 }
@@ -1338,17 +1370,18 @@ LoadGaussMesh(const MED::PWrapper& theMed,
 
 //---------------------------------------------------------------
 int 
-VISU_MedConvertor
-::LoadField(const MED::PWrapper& theMed,
-	    VISU::PMEDMesh theMesh,
-	    VISU::PMEDMeshOnEntity theMeshOnEntity,
-	    VISU::PMEDField theField, 
-	    VISU::PMEDValForTime theValForTime)
+LoadValForTime(const MED::PWrapper& theMed,
+	       VISU::PMEDMesh theMesh,
+	       VISU::PMEDMeshOnEntity theMeshOnEntity,
+	       VISU::PMEDField theField, 
+	       VISU::PMEDValForTime theValForTime,
+	       bool theIsGauss)
 {
-  INITMSG(MYDEBUG,"LoadField"<<endl);
+  INITMSG(MYDEBUG,"LoadValForTime - theIsGauss = "<<theIsGauss<<endl);
 
   //Check on loading already done
-  if(theValForTime->myIsDone) 
+  TSource& aMeshSource = theValForTime->myMeshSource;
+  if(aMeshSource.myIsDone) 
     return 0;
 
   //Main part of code
@@ -1382,11 +1415,12 @@ VISU_MedConvertor
 	      theValForTime,
 	      theMeshOnEntity);
   
-  LoadGaussMesh(theMed,
-		theMesh,
-		aTimeStampVal,
-		theValForTime,
-		theMeshOnEntity);
+  if(theIsGauss)
+    LoadGaussMesh(theMed,
+		  theMesh,
+		  aTimeStampVal,
+		  theValForTime,
+		  theMeshOnEntity);
   
   PMEDProfile aProfile = theValForTime->myProfile;
   TGeom2SubProfile& aGeom2SubProfile = aProfile->myGeom2SubProfile;
@@ -1445,7 +1479,33 @@ VISU_MedConvertor
     }
   }
 
-  theValForTime->myIsDone = true;
+  aMeshSource.myIsDone = true;
 
   return 1; 
 }
+
+
+//---------------------------------------------------------------
+int 
+VISU_MedConvertor
+::LoadValForTimeOnMesh(const MED::PWrapper& theMed,
+		       VISU::PMEDMesh theMesh,
+		       VISU::PMEDMeshOnEntity theMeshOnEntity,
+		       VISU::PMEDField theField, 
+		       VISU::PMEDValForTime theValForTime)
+{
+  return LoadValForTime(theMed,theMesh,theMeshOnEntity,theField,theValForTime,false);
+}
+
+
+//---------------------------------------------------------------
+int 
+VISU_MedConvertor
+::LoadValForTimeOnGaussPts(const MED::PWrapper& theMed,
+			   VISU::PMEDMesh theMesh,
+			   VISU::PMEDMeshOnEntity theMeshOnEntity,
+			   VISU::PMEDField theField, 
+			   VISU::PMEDValForTime theValForTime)
+{
+  return LoadValForTime(theMed,theMesh,theMeshOnEntity,theField,theValForTime,true);
+}
diff --git a/src/CONVERTOR/VISU_MedConvertor.hxx b/src/CONVERTOR/VISU_MedConvertor.hxx
index bb187c23..6bfb8a21 100644
--- a/src/CONVERTOR/VISU_MedConvertor.hxx
+++ b/src/CONVERTOR/VISU_MedConvertor.hxx
@@ -56,14 +56,8 @@ namespace VISU
     MED::TElemNum myElemNum;
 
     virtual
-    vtkIdType
-    GetObjID(vtkIdType theID) const
-    {
-      if(myIsElemNum)
-	return myElemNum[theID];
-      else
-	return theID;
-    }
+    TGaussPointID
+    GetObjID(vtkIdType theID) const;
   };
   typedef SharedPtr<TMEDGaussSubMesh> PMEDGaussSubMesh;
 
@@ -101,7 +95,7 @@ namespace VISU
 
 
   //---------------------------------------------------------------
-  struct TMEDValForTime: virtual TValForTimeImpl
+  struct TMEDValForTime: virtual TGaussPtsValForTimeImpl
   {};
   typedef SharedPtr<TMEDValForTime> PMEDValForTime;
 
@@ -134,11 +128,18 @@ protected:
   
   virtual
   int
-  LoadFieldOnMesh(VISU::PMeshImpl theMesh, 
-		  VISU::PMeshOnEntityImpl theMeshOnEntity, 
-		  VISU::PFieldImpl theField, 
-		  VISU::PValForTimeImpl theValForTime);
+  LoadValForTimeOnMesh(VISU::PMeshImpl theMesh, 
+		       VISU::PMeshOnEntityImpl theMeshOnEntity, 
+		       VISU::PFieldImpl theField, 
+		       VISU::PValForTimeImpl theValForTime);
   
+  virtual 
+  int
+  LoadValForTimeOnGaussPts(VISU::PMeshImpl theMesh, 
+			   VISU::PMeshOnEntityImpl theMeshOnEntity, 
+			   VISU::PFieldImpl theField, 
+			   VISU::PValForTimeImpl theValForTime);
+
   int
   LoadPoints(const MED::PWrapper& theMed,
 	     VISU::PMEDMesh theMesh, 
@@ -151,12 +152,18 @@ protected:
 		    const std::string& theFamilyName = "");
   
   int
-  LoadField(const MED::PWrapper& theMed,
-	    VISU::PMEDMesh theMesh,
-	    VISU::PMEDMeshOnEntity theMeshOnEntity,
-	    VISU::PMEDField theField, 
-	    VISU::PMEDValForTime theValForTime);
+  LoadValForTimeOnMesh(const MED::PWrapper& theMed,
+		       VISU::PMEDMesh theMesh,
+		       VISU::PMEDMeshOnEntity theMeshOnEntity,
+		       VISU::PMEDField theField, 
+		       VISU::PMEDValForTime theValForTime);
   
+  int
+  LoadValForTimeOnGaussPts(const MED::PWrapper& theMed,
+			   VISU::PMEDMesh theMesh,
+			   VISU::PMEDMeshOnEntity theMeshOnEntity,
+			   VISU::PMEDField theField, 
+			   VISU::PMEDValForTime theValForTime);
 };
 
 #endif
diff --git a/src/VISU_I/VISU_CorbaMedConvertor.cxx b/src/VISU_I/VISU_CorbaMedConvertor.cxx
index ed5c29e0..4d2df3a2 100644
--- a/src/VISU_I/VISU_CorbaMedConvertor.cxx
+++ b/src/VISU_I/VISU_CorbaMedConvertor.cxx
@@ -912,10 +912,10 @@ VISU_MEDConvertor::LoadMeshOnGroup(VISU::PMeshImpl theMesh,
 
 //---------------------------------------------------------------
 int 
-VISU_MEDConvertor::LoadFieldOnMesh(VISU::PMeshImpl theMesh, 
-				   VISU::PMeshOnEntityImpl theMeshOnEntity, 
-				   VISU::PFieldImpl theField, 
-				   VISU::PValForTimeImpl theValForTime)
+VISU_MEDConvertor::LoadValForTimeOnMesh(VISU::PMeshImpl theMesh, 
+					VISU::PMeshOnEntityImpl theMeshOnEntity, 
+					VISU::PFieldImpl theField, 
+					VISU::PValForTimeImpl theValForTime)
 {
   //Main part of code
   int isPointsUpdated = LoadPoints(theMesh);
@@ -1213,7 +1213,8 @@ VISU_MEDConvertor::LoadField(VISU::PCMesh theMesh,
 			     VISU::PCValForTime theValForTime)
 {
   //Check on loading already done
-  if(theValForTime->myIsDone) 
+  TSource& aMeshSource = theValForTime->myMeshSource;
+  if(aMeshSource.myIsDone) 
     return 0;
   
   SALOME_MED::FIELD_var aMEDField = theValForTime->myField;
@@ -1230,7 +1231,7 @@ VISU_MEDConvertor::LoadField(VISU::PCMesh theMesh,
     ::ImportField(anArray,theMesh,theField,theValForTime,theMeshOnEntity);
   }
 
-  theValForTime->myIsDone = true;
+  aMeshSource.myIsDone = true;
 
   return 1;
 }
diff --git a/src/VISU_I/VISU_CorbaMedConvertor.hxx b/src/VISU_I/VISU_CorbaMedConvertor.hxx
index 376eff77..35ff1aca 100644
--- a/src/VISU_I/VISU_CorbaMedConvertor.hxx
+++ b/src/VISU_I/VISU_CorbaMedConvertor.hxx
@@ -79,7 +79,7 @@ namespace VISU
 
 
   //---------------------------------------------------------------
-  struct TCValForTime: virtual TValForTimeImpl
+  struct TCValForTime: virtual TGaussPtsValForTimeImpl
   {
     SALOME_MED::FIELD_var myField;
   };
@@ -94,36 +94,61 @@ class VISU_MEDConvertor: public VISU_Convertor_impl{
   VISU_MEDConvertor() {};
 
  public:
-  VISU_MEDConvertor(SALOMEDS::SObject_ptr theMedSObject) : mySObject(SALOMEDS::SObject::_duplicate(theMedSObject)) {}
-  virtual VISU_Convertor* Build();
-
- protected:
+  VISU_MEDConvertor(SALOMEDS::SObject_ptr theMedSObject): 
+    mySObject(SALOMEDS::SObject::_duplicate(theMedSObject)) 
+  {}
 
-  VISU_Convertor* Build(SALOME_MED::MED_ptr theMED);
-  VISU_Convertor* Build(SALOMEDS::ChildIterator_ptr theTimeStampIterator);
+  virtual
+  VISU_Convertor* 
+  Build();
 
-  virtual int LoadMeshOnEntity(VISU::PMeshOnEntityImpl theMeshOnEntity, 
-			       const std::string& theFamilyName = "");
+ protected:
 
-  virtual int LoadMeshOnGroup(VISU::PMeshImpl theMesh, 
-			      const VISU::TFamilyAndEntitySet& theFamilyAndEntitySet);
+  VISU_Convertor* 
+  Build(SALOME_MED::MED_ptr theMED);
+  
+  VISU_Convertor* 
+  Build(SALOMEDS::ChildIterator_ptr theTimeStampIterator);
 
-  virtual int LoadFieldOnMesh(VISU::PMeshImpl theMesh, 
-			      VISU::PMeshOnEntityImpl theMeshOnEntity, 
-			      VISU::PFieldImpl theField, 
-			      VISU::PValForTimeImpl theValForTime);
+  virtual
+  int
+  LoadMeshOnEntity(VISU::PMeshOnEntityImpl theMeshOnEntity, 
+		   const std::string& theFamilyName = "");
+  
+  virtual
+  int
+  LoadMeshOnGroup(VISU::PMeshImpl theMesh, 
+		  const VISU::TFamilyAndEntitySet& theFamilyAndEntitySet);
+
+  virtual 
+  int
+  LoadValForTimeOnMesh(VISU::PMeshImpl theMesh, 
+		       VISU::PMeshOnEntityImpl theMeshOnEntity, 
+		       VISU::PFieldImpl theField, 
+		       VISU::PValForTimeImpl theValForTime);
+
+  virtual
+  int
+  LoadValForTimeOnGaussPts(VISU::PMeshImpl theMesh, 
+			   VISU::PMeshOnEntityImpl theMeshOnEntity, 
+			   VISU::PFieldImpl theField, 
+			   VISU::PValForTimeImpl theValForTime)
+  {}
 
-  int LoadPoints(VISU::PCMesh theMesh,
-		 const std::string& theFamilyName = "") ;
+  int 
+  LoadPoints(VISU::PCMesh theMesh,
+	     const std::string& theFamilyName = "") ;
 
-  int LoadCellsOnEntity(VISU::PCMesh theMesh,
-			VISU::PCMeshOnEntity theMeshOnEntity, 
-			const std::string& theFamilyName = "");
+  int 
+  LoadCellsOnEntity(VISU::PCMesh theMesh,
+		    VISU::PCMeshOnEntity theMeshOnEntity, 
+		    const std::string& theFamilyName = "");
   
-  int LoadField(VISU::PCMesh theMesh,
-		VISU::PCMeshOnEntity theMeshOnEntity,
-		VISU::PField theField, 
-		VISU::PCValForTime theValForTime);
+  int 
+  LoadField(VISU::PCMesh theMesh,
+	    VISU::PCMeshOnEntity theMeshOnEntity,
+	    VISU::PField theField, 
+	    VISU::PCValForTime theValForTime);
 
 };
 
diff --git a/src/VISU_I/VISU_GaussPoints_i.cc b/src/VISU_I/VISU_GaussPoints_i.cc
index 81d2c463..71c175e5 100644
--- a/src/VISU_I/VISU_GaussPoints_i.cc
+++ b/src/VISU_I/VISU_GaussPoints_i.cc
@@ -123,8 +123,21 @@ VISU::GaussPoints_i
 }
 
 
-void VISU::GaussPoints_i::DoSetInput(Result_i* theResult){
-  ScalarMap_i::DoSetInput(theResult);
+void
+VISU::GaussPoints_i
+::DoSetInput(Result_i* theResult)
+{
+  if(theResult->GetInput() == NULL)
+    throw std::runtime_error("Mesh_i::Build - theResult->GetInput() == NULL !!!");
+  myField = theResult->GetInput()->GetField(myMeshName,myEntity,myFieldName);
+  if(myField == NULL) 
+    throw std::runtime_error("There is no Field with the parameters !!!");
+  VISU_Convertor::TOutput *anOutput =
+    theResult->GetInput()->GetGaussPointsOnMesh(myMeshName,myEntity,myFieldName,myIteration);
+  if(anOutput == NULL) 
+    throw std::runtime_error("There is no TimeStamp with the parameters !!!");
+  myScalarMapPL->SetInput(anOutput);
+  myScalarMapPL->Build();
 }