static int MYDEBUGWITHFILES = 0;
#endif
+//#define ENABLE_QUADRATIC
+
namespace VISU
{
//---------------------------------------------------------------
//---------------------------------------------------------------
TSubProfileImpl::TSubProfileImpl():
- myStatus(eNone)
- {
- myGeom = -1;
- }
+ myStatus(eNone),
+ myGeom(eNONE)
+ {}
vtkIdType
const TMeshValue&
TValForTimeImpl
- ::GetMeshValue(vtkIdType theGeom) const
+ ::GetMeshValue(EGeometry theGeom) const
{
TGeom2Value::const_iterator anIter = myGeom2Value.find(theGeom);
if(anIter == myGeom2Value.end())
TMeshValue&
TValForTimeImpl
- ::GetMeshValue(vtkIdType theGeom)
+ ::GetMeshValue(EGeometry theGeom)
{
return myGeom2Value[theGeom];
}
int
TValForTimeImpl
- ::GetNbGauss(vtkIdType theGeom) const
+ ::GetNbGauss(EGeometry theGeom) const
{
if(PGaussMeshImpl aGaussMesh = myGaussMesh){
const TGeom2GaussSubMesh& aGeom2GaussSubMesh = aGaussMesh->myGeom2GaussSubMesh;
//---------------------------------------------------------------
vtkIdType
- VTKGeom2NbNodes(vtkIdType theGeom)
+ VISUGeom2NbNodes(EGeometry theGeom)
{
switch(theGeom){
- case VTK_VERTEX: return 1;
- case VTK_LINE: return 2;
- case VTK_TRIANGLE: return 3;
- case VTK_QUAD: return 4;
- case VTK_TETRA: return 4;
- case VTK_HEXAHEDRON: return 8;
- case VTK_WEDGE: return 6;
- case VTK_PYRAMID: return 5;
-
- case QUADRATIC_EDGE: return 3;
- case QUADRATIC_TRIANGLE: return 6;
- case QUADRATIC_QUAD: return 8;
- case QUADRATIC_TETRA: return 10;
- case QUADRATIC_HEXAHEDRON: return 20;
- case QUADRATIC_WEDGE: return 15;
- case QUADRATIC_PYRAMID: return 13;
+ case VISU::ePOLYGONE:
+ case VISU::ePOLYEDRE:
+ return -1;
+ default:
+ return theGeom % 100;
}
- return -1;
}
vtkIdType
- VTKGeom2VISU(vtkIdType theGeom)
+ VISUGeom2VTK(EGeometry theGeom)
{
switch(theGeom){
- case QUADRATIC_EDGE: return VTK_POLY_LINE;
- case QUADRATIC_TRIANGLE: return VTK_POLYGON;
- case QUADRATIC_QUAD: return VTK_POLYGON;
- case QUADRATIC_TETRA: return VTK_CONVEX_POINT_SET;
- case QUADRATIC_HEXAHEDRON: return VTK_CONVEX_POINT_SET;
- case QUADRATIC_WEDGE: return VTK_CONVEX_POINT_SET;
- case QUADRATIC_PYRAMID: return VTK_CONVEX_POINT_SET;
+ case VISU::ePOINT1:
+ return VTK_VERTEX;
+ case VISU::eSEG2:
+ return VTK_LINE;
+ case VISU::eTRIA3:
+ return VTK_TRIANGLE;
+ case VISU::eQUAD4:
+ return VTK_QUAD;
+ case VISU::eTETRA4:
+ return VTK_TETRA;
+ case VISU::eHEXA8:
+ return VTK_HEXAHEDRON;
+ case VISU::ePENTA6:
+ return VTK_WEDGE;
+ case VISU::ePYRA5:
+ return VTK_PYRAMID;
+
+ case VISU::ePOLYGONE:
+ return VTK_POLYGON;
+ case VISU::ePOLYEDRE:
+ return VTK_CONVEX_POINT_SET;
+
+#ifndef ENABLE_QUADRATIC
+ case VISU::eSEG3:
+ return VTK_LINE;
+ case VISU::eTRIA6:
+ return VTK_TRIANGLE;
+ case VISU::eQUAD8:
+ return VTK_QUAD;
+ case VISU::eTETRA10:
+ return VTK_TETRA;
+ case VISU::eHEXA20:
+ return VTK_HEXAHEDRON;
+ case VISU::ePENTA15:
+ return VTK_WEDGE;
+ case VISU::ePYRA13:
+ return VTK_PYRAMID;
+
+#else
+
+ case VISU::eSEG3:
+#ifdef VTK_QUADRATIC_EDGE
+ return VTK_QUADRATIC_EDGE;
+#else
+ return VTK_POLY_LINE;
+#endif
+
+ case VISU::eTRIA6:
+#ifdef VTK_QUADRATIC_TRIANGLE
+ return VTK_QUADRATIC_TRIANGLE;
+#else
+ return VTK_POLYGON;
+#endif
+
+ case VISU::eQUAD8:
+#ifdef VTK_QUADRATIC_QUAD
+ return VTK_QUADRATIC_QUAD;
+#else
+ return VTK_POLYGON;
+#endif
+
+ case VISU::eTETRA10:
+#ifdef VTK_QUADRATIC_TETRA
+ return VTK_QUADRATIC_QUAD;
+#else
+ return VTK_CONVEX_POINT_SET;
+#endif
+
+ case VISU::eHEXA20:
+#ifdef VTK_QUADRATIC_HEXAHEDRON
+ return VTK_QUADRATIC_HEXAHEDRON;
+#else
+ return VTK_CONVEX_POINT_SET;
+#endif
+
+ case VISU::ePENTA15:
+#ifdef VTK_QUADRATIC_WEDGE
+ return VTK_QUADRATIC_WEDGE;
+#else
+ return VTK_CONVEX_POINT_SET;
+#endif
+
+ case VISU::ePYRA13:
+#ifdef VTK_QUADRATIC_PYRAMID
+ return VTK_QUADRATIC_PYRAMID;
+#else
+ return VTK_CONVEX_POINT_SET;
+#endif
+
+#endif //ENABLE_QUADRATIC
+
+ default:
+ return -1;
}
- return theGeom;
}
}
const VISU::TGeom2SubMesh& aGeom2SubMesh = theMeshOnEntity->myGeom2SubMesh;
VISU::TGeom2SubMesh::const_iterator anIter = aGeom2SubMesh.begin();
for(vtkIdType i = 0, j = 0; anIter != aGeom2SubMesh.end(); anIter++){
- const vtkIdType& aGeom = anIter->first;
+ VISU::EGeometry aEGeom = anIter->first;
+ vtkIdType aVGeom = VISUGeom2VTK(aEGeom);
const VISU::TSubMeshImpl& aSubMesh = anIter->second;
const VISU::TCell2Connect& anArray = aSubMesh.myCell2Connect;
if(aGeom2SubMeshID.empty())
EXCEPTION(runtime_error,"GetCells >> There is no elements on the family !!!");
- VISU::TGeom2SubMeshID::const_iterator aGeom2SubMeshIDIter = aGeom2SubMeshID.find(aGeom);
+ VISU::TGeom2SubMeshID::const_iterator aGeom2SubMeshIDIter = aGeom2SubMeshID.find(aEGeom);
if(aGeom2SubMeshIDIter == aGeom2SubMeshID.end())
continue;
const VISU::TSubMeshID& aSubMeshID = aGeom2SubMeshIDIter->second;
- INITMSG(MYDEBUG,"aGeom = "<<aGeom<<
+ INITMSG(MYDEBUG,"aEGeom = "<<aEGeom<<
"; aSubMeshID.size() = "<<aSubMeshID.size()<<
endl);
for(; aSubMeshIDIter != aSubMeshID.end(); aSubMeshIDIter++, i++){
vtkIdType anID = *aSubMeshIDIter;
PrintCells(i,aConnectivity,anArray[anID]);
- aCellTypesArray->SetValue(j++,(unsigned char)aGeom);
+ aCellTypesArray->SetValue(j++,(unsigned char)aVGeom);
anElemObj2VTKID[anID] = i;
aMeshID[i] = anID;
TGeom2Value::const_iterator anIter = aGeom2Value.begin();
TVector<float> aDataValues(aNbComp);
for(int aTupleId = 0; anIter != aGeom2Value.end(); anIter++){
- int aGeom = anIter->first;
+ EGeometry aEGeom = anIter->first;
const TMeshValue& aMeshValue = anIter->second;
int aNbElem = aMeshValue.myNbElem;
int aNbGauss = aMeshValue.myNbGauss;
INITMSG(MYDEBUG,
- "- aGeom = "<<aGeom<<
+ "- aEGeom = "<<aEGeom<<
"; aNbElem = "<<aNbElem<<
"; aNbComp = "<<aNbComp<<
"; aNbGauss = "<<aNbGauss<<
{
vtkIdType aNbCells = theSubProfile->myNbCells;
vtkIdType aCellsSize = theSubProfile->myCellsSize;
- vtkIdType aVGeom = theSubProfile->myGeom;
- vtkIdType aNbNodes = VTKGeom2NbNodes(aVGeom);
- vtkIdType aGeom = VTKGeom2VISU(aVGeom);
+ VISU::EGeometry aEGeom = theSubProfile->myGeom;
+ vtkIdType aNbNodes = VISUGeom2NbNodes(aEGeom);
+ vtkIdType aVGeom = VISUGeom2VTK(aEGeom);
const TSubMeshID& aSubMeshID = theSubProfile->mySubMeshID;
const VISU::TGeom2SubMesh& aGeom2SubMesh = theMeshOnEntity->myGeom2SubMesh;
- VISU::TGeom2SubMesh::const_iterator anIter = aGeom2SubMesh.find(aVGeom);
+ VISU::TGeom2SubMesh::const_iterator anIter = aGeom2SubMesh.find(aEGeom);
if(anIter == aGeom2SubMesh.end())
- EXCEPTION(runtime_error,"GetCells >> There is no elements for the GEOM("<<aVGeom<<")");
+ EXCEPTION(runtime_error,"GetCells >> There is no elements for the GEOM("<<aEGeom<<")");
const VISU::TSubMeshImpl& aSubMesh = anIter->second;
const TCell2Connect& aCell2Connect = aSubMesh.myCell2Connect;
for(vtkIdType anId = 0, aConnId = 0; anIter != aCell2Connect.end(); anIter++){
const TConnect& anArray = aCell2Connect[anId];
PrintCells(aConnId,aConnectivity,anArray);
- aCellTypesArray->SetValue(anId,(unsigned char)aGeom);
+ aCellTypesArray->SetValue(anId,(unsigned char)aVGeom);
aConnId += aNbNodes;
anId++;
}
vtkIdType aSubId = *anIter;
const TConnect& anArray = aCell2Connect[aSubId];
PrintCells(aConnId,aConnectivity,anArray);
- aCellTypesArray->SetValue(anId,(unsigned char)aGeom);
+ aCellTypesArray->SetValue(anId,(unsigned char)aVGeom);
aConnId += aNbNodes;
anId++;
}
const PProfileImpl& theProfile,
const PSubProfileImpl& theSubProfile)
{
- INITMSG(MYDEBUG,"GetMeshOnSubProfile - aVGeom = "<<theSubProfile->myGeom<<endl);
+ INITMSG(MYDEBUG,"GetMeshOnSubProfile - aEGeom = "<<theSubProfile->myGeom<<endl);
const TVTKSource& aSource = theSubProfile->GetSource();
if(theSubProfile->myIsVTKDone)
TGeom2GaussSubMesh::const_iterator anIter = aGeom2GaussSubMesh.begin();
TVector<float> aDataValues(aNbComp);
for(int aTupleId = 0; anIter != aGeom2GaussSubMesh.end(); anIter++){
- vtkIdType aVGeom = anIter->first;
+ EGeometry aEGeom = anIter->first;
+ vtkIdType aVGeom = VISUGeom2VTK(aEGeom);
+
PGaussSubMeshImpl aGaussSubMesh = anIter->second;
if(!aGaussSubMesh->myIsDone)
continue;
- TGeom2Value::const_iterator anIter2 = aGeom2Value.find(aVGeom);
+ TGeom2Value::const_iterator anIter2 = aGeom2Value.find(aEGeom);
if(anIter2 == aGeom2Value.end()){
EXCEPTION(runtime_error,
"GetTimeStampOnGaussMesh >> Can't find values for corresponding Gauss Points SubMesh");
if(aNbGauss < 1)
continue;
- INITMSG(MYDEBUG,"- aVGeom = "<<aVGeom<<
+ INITMSG(MYDEBUG,
+ "- aEGeom = "<<aEGeom<<
"; aNbElem = "<<aNbElem<<
"; aNbComp = "<<aNbComp<<
"; aNbGauss = "<<aNbGauss<<
aSubMeshArr.resize(aGeom2SubMesh.size());
for(vtkIdType anID = 0, aCellID = 0; anIter != aGeom2SubMesh.end(); anIter++, anID++){
- const vtkIdType& aVGeom = anIter->first;
+ EGeometry aEGeom = anIter->first;
+ vtkIdType aVGeom = VISUGeom2VTK(aEGeom);
PSubMeshImpl aSubMesh = anIter->second;
const TVTKSource& aSource = aSubMesh->GetSource();
aSource->SetPoints(GetPoints(aMesh));
namespace VISU
{
- const vtkIdType QUADRATIC_EDGE = 30;
- const vtkIdType QUADRATIC_TRIANGLE = 31;
- const vtkIdType QUADRATIC_QUAD = 32;
- const vtkIdType QUADRATIC_TETRA = 33;
- const vtkIdType QUADRATIC_HEXAHEDRON = 34;
- const vtkIdType QUADRATIC_WEDGE = 35;
- const vtkIdType QUADRATIC_PYRAMID = 36;
+ enum EGeometry {ePOINT1=1, eSEG2=102, eSEG3=103, eTRIA3=203,
+ eQUAD4=204, eTRIA6=206,eQUAD8=208, eTETRA4=304,
+ ePYRA5=305, ePENTA6=306, eHEXA8=308, eTETRA10=310,
+ ePYRA13=313, ePENTA15=315, eHEXA20=320,
+ ePOLYGONE=400, ePOLYEDRE=500, eNONE=-1};
+ vtkIdType
+ VISUGeom2NbNodes(EGeometry theGeom);
+
+ vtkIdType
+ VISUGeom2VTK(EGeometry theGeom);
+
+ //---------------------------------------------------------------
using MED::TCSlice;
using MED::TSlice;
{
TSubProfileImpl();
- vtkIdType myGeom;
+ EGeometry myGeom;
std::string myName;
virtual
typedef std::map<vtkIdType,vtkIdType> TID2ID;
typedef TVector<PSubProfileImpl> TSubProfileArr;
- typedef std::map<vtkIdType,PSubProfileImpl> TGeom2SubProfile;
+ typedef std::map<EGeometry,PSubProfileImpl> TGeom2SubProfile;
struct TProfileImpl: virtual TProfile,
virtual TAppendFilter
//---------------------------------------------------------------
struct TGaussImpl: virtual TGauss
{
- vtkIdType myGeom;
+ EGeometry myGeom;
std::string myName;
vtkIdType myNbPoints;
};
//---------------------------------------------------------------
typedef TVector<PGaussSubMeshImpl> TGaussSubMeshArr;
- typedef std::map<vtkIdType,PGaussSubMeshImpl> TGeom2GaussSubMesh;
+ typedef std::map<EGeometry,PGaussSubMeshImpl> TGeom2GaussSubMesh;
struct TGaussMeshImpl: virtual TGaussMesh,
virtual TAppendFilter
//---------------------------------------------------------------
- typedef std::map<vtkIdType,PSubMeshImpl> TGeom2SubMesh;
+ typedef std::map<EGeometry,PSubMeshImpl> TGeom2SubMesh;
typedef TVector<PSubMeshImpl> TSubMeshArr;
struct TMeshOnEntityImpl: virtual TMeshOnEntity,
//---------------------------------------------------------------
- typedef std::map<vtkIdType,TSubMeshID> TGeom2SubMeshID;
+ typedef std::map<EGeometry,TSubMeshID> TGeom2SubMeshID;
struct TFamilyImpl: virtual TFamily,
virtual TSource
//---------------------------------------------------------------
- typedef std::map<vtkIdType,TMeshValue> TGeom2Value;
+ typedef std::map<EGeometry,TMeshValue> TGeom2Value;
struct TValForTimeImpl: virtual TValForTime
{
TValForTimeImpl();
const TMeshValue&
- GetMeshValue(vtkIdType theGeom) const;
+ GetMeshValue(EGeometry theGeom) const;
TMeshValue&
- GetMeshValue(vtkIdType theGeom);
+ GetMeshValue(EGeometry theGeom);
virtual
int
- GetNbGauss(vtkIdType theGeom) const;
+ GetNbGauss(EGeometry theGeom) const;
};
typedef SharedPtr<TValForTimeImpl> PValForTimeImpl;
-
-
- //---------------------------------------------------------------
- vtkIdType
- VTKGeom2NbNodes(vtkIdType theGeom);
}
#define _EDF_NODE_IDS_
#define _NAME_MAPPING_ 0
+//#define ENABLE_QUADRATIC
+
namespace
{
//---------------------------------------------------------------
//---------------------------------------------------------------
- vtkIdType
- MEDGeomToVTK(MED::EGeometrieElement theMEDGeomType)
+ VISU::EGeometry
+ MEDGeom2VISU(MED::EGeometrieElement theGeom)
{
- switch(theMEDGeomType){
- case MED::ePOINT1: return VTK_VERTEX;
- case MED::eSEG2: return VTK_LINE;
- case MED::eTRIA3: return VTK_TRIANGLE;
- case MED::eQUAD4: return VTK_QUAD;
- case MED::eTETRA4: return VTK_TETRA;
- case MED::eHEXA8: return VTK_HEXAHEDRON;
- case MED::ePENTA6: return VTK_WEDGE;
- case MED::ePYRA5: return VTK_PYRAMID;
-
- case MED::eSEG3: return VISU::QUADRATIC_EDGE;
- case MED::eTRIA6: return VISU::QUADRATIC_TRIANGLE;
- case MED::eQUAD8: return VISU::QUADRATIC_QUAD;
- case MED::eTETRA10: return VISU::QUADRATIC_TETRA;
- case MED::eHEXA20: return VISU::QUADRATIC_HEXAHEDRON;
- case MED::ePENTA15: return VISU::QUADRATIC_WEDGE;
- case MED::ePYRA13: return VISU::QUADRATIC_PYRAMID;
-
- case MED::ePOLYGONE: return VTK_POLYGON;
- case MED::ePOLYEDRE: return VTK_CONVEX_POINT_SET;
+ switch(theGeom){
+ case MED::ePOINT1: return VISU::ePOINT1;
+ case MED::eSEG2: return VISU::eSEG2;
+ case MED::eTRIA3: return VISU::eTRIA3;
+ case MED::eQUAD4: return VISU::eQUAD4;
+ case MED::eTETRA4: return VISU::eTETRA4;
+ case MED::eHEXA8: return VISU::eHEXA8;
+ case MED::ePENTA6: return VISU::ePENTA6;
+ case MED::ePYRA5: return VISU::ePYRA5;
+
+ case MED::eSEG3: return VISU::eSEG3;
+ case MED::eTRIA6: return VISU::eTRIA6;
+ case MED::eQUAD8: return VISU::eQUAD8;
+ case MED::eTETRA10: return VISU::eTETRA10;
+ case MED::eHEXA20: return VISU::eHEXA20;
+ case MED::ePENTA15: return VISU::ePENTA15;
+ case MED::ePYRA13: return VISU::ePYRA13;
+
+ case MED::ePOLYGONE: return VISU::ePOLYGONE;
+ case MED::ePOLYEDRE: return VISU::ePOLYEDRE;
}
- return -1;
+ return VISU::eNONE;
}
//---------------------------------------------------------------
MED::EGeometrieElement
- VTKGeomToMED(int theVTKGeomType)
+ VISUGeom2MED(int theGeom)
{
- switch(theVTKGeomType){
- case VTK_VERTEX: return MED::ePOINT1;
- case VTK_LINE: return MED::eSEG2;
- case VTK_TRIANGLE: return MED::eTRIA3;
- case VTK_QUAD: return MED::eQUAD4;
- case VTK_TETRA: return MED::eTETRA4;
- case VTK_HEXAHEDRON: return MED::eHEXA8;
- case VTK_WEDGE: return MED::ePENTA6;
- case VTK_PYRAMID: return MED::ePYRA5;
-
- case VISU::QUADRATIC_EDGE: return MED::eSEG3;
- case VISU::QUADRATIC_TRIANGLE: return MED::eTRIA6;
- case VISU::QUADRATIC_QUAD: return MED::eQUAD8;
- case VISU::QUADRATIC_TETRA: return MED::eTETRA10;
- case VISU::QUADRATIC_HEXAHEDRON: return MED::eHEXA20;
- case VISU::QUADRATIC_WEDGE: return MED::ePENTA15;
- case VISU::QUADRATIC_PYRAMID: return MED::ePYRA13;
-
- case VTK_POLYGON: return MED::ePOLYGONE;
- case VTK_CONVEX_POINT_SET: return MED::ePOLYEDRE;
+ switch(theGeom){
+ case VISU::ePOINT1: return MED::ePOINT1;
+ case VISU::eSEG2: return MED::eSEG2;
+ case VISU::eTRIA3: return MED::eTRIA3;
+ case VISU::eQUAD4: return MED::eQUAD4;
+ case VISU::eTETRA4: return MED::eTETRA4;
+ case VISU::eHEXA8: return MED::eHEXA8;
+ case VISU::ePENTA6: return MED::ePENTA6;
+ case VISU::ePYRA5: return MED::ePYRA5;
+
+ case VISU::eSEG3: return MED::eSEG3;
+ case VISU::eTRIA6: return MED::eTRIA6;
+ case VISU::eQUAD8: return MED::eQUAD8;
+ case VISU::eTETRA10: return MED::eTETRA10;
+ case VISU::eHEXA20: return MED::eHEXA20;
+ case VISU::ePENTA15: return MED::ePENTA15;
+ case VISU::ePYRA13: return MED::ePYRA13;
+
+ case VISU::ePOLYGONE: return MED::ePOLYGONE;
+ case VISU::ePOLYEDRE: return MED::ePOLYEDRE;
}
return MED::EGeometrieElement(-1);
}
//---------------------------------------------------------------
- TEntity
+ VISU::TEntity
MEDEntityToVTK(MED::EEntiteMaillage theMEDEntity)
{
switch(theMEDEntity){
case MED::eFACE: return FACE_ENTITY;
case MED::eMAILLE: return CELL_ENTITY;
}
- return TEntity(-1);
+ return VISU::TEntity(-1);
}
const MED::TGeom2Size& theGeom2Size,
const MED::TGeom2Profile& theGeom2Profile)
{
- vtkIdType aVGeom = MEDGeomToVTK(theMGeom);
- vtkIdType aVNbNodes = VTKGeom2NbNodes(aVGeom);
+ VISU::EGeometry aEGeom = MEDGeom2VISU(theMGeom);
+ vtkIdType aVNbNodes = VISUGeom2NbNodes(aEGeom);
PMEDSubProfile aSubProfile(new TMEDSubProfile());
- aSubProfile->myGeom = aVGeom;
+ aSubProfile->myGeom = aEGeom;
aSubProfile->myMGeom = theMGeom;
aSubProfile->myStatus = eAddAll;
}
INITMSG(MYDEBUG,
"- aMGeom = "<<theMGeom<<
- "; aVGeom = "<<aVGeom<<
+ "; aEGeom = "<<aEGeom<<
"; aName = '"<<aSubProfile->myName<<"'"<<
"; aStatus = "<<aSubProfile->myStatus<<
"; aNbCells = "<<aSubProfile->myNbCells<<
if(aProfile->myIsAll && aSubProfile->myStatus != eAddAll)
aProfile->myIsAll = false;
- vtkIdType aVGeom = aSubProfile->myGeom;
- aGeom2SubProfile[aVGeom] = aSubProfile;
+ VISU::EGeometry aEGeom = aSubProfile->myGeom;
+ aGeom2SubProfile[aEGeom] = aSubProfile;
}
aProfileMap[aProfileKey] = aProfile;
MED::TGeom2Size::const_iterator anIter = aGeom2Size.begin();
for(; anIter != aGeom2Size.end(); anIter++){
MED::EGeometrieElement aMGeom = anIter->first;
- vtkIdType aVGeom = MEDGeomToVTK(aMGeom);
+ VISU::EGeometry aEGeom = MEDGeom2VISU(aMGeom);
- TGeom2SubProfile::iterator anIter2 = aGeom2SubProfile.find(aVGeom);
+ TGeom2SubProfile::iterator anIter2 = aGeom2SubProfile.find(aEGeom);
if(anIter2 == aGeom2SubProfile.end()){
INITMSG(MYDEBUG,"anIter2 == aGeom2SubProfile.end!!"<<endl);
continue;
PMEDGauss aGauss(new TMEDGauss());
aGaussSubMesh->myGauss = aGauss;
- aGauss->myGeom = aVGeom;
+ aGauss->myGeom = aEGeom;
TInt aNbGauss = 1;
std::string aName;
aGaussKey.insert(aGaussSubMesh);
INITMSGA(MYDEBUG,0,
- "- aVGeom = "<<aVGeom<<
+ "- aEGeom = "<<aEGeom<<
"; aName = '"<<aName<<"'"<<
"; aNbGauss = "<<aNbGauss<<
"; aStatus = "<<aGaussSubMesh->myStatus<<
for(; anIter != aGaussKey.end(); anIter++){
PMEDGaussSubMesh aGaussSubMesh(*anIter);
PMEDGauss aGauss = aGaussSubMesh->myGauss;
- vtkIdType aVGeom = aGauss->myGeom;
- aGeom2GaussSubMesh[aVGeom] = aGaussSubMesh;
+ VISU::EGeometry aEGeom = aGauss->myGeom;
+ aGeom2GaussSubMesh[aEGeom] = aGaussSubMesh;
}
}
{
break;
}
default: {
- vtkIdType aVGeom = MEDGeomToVTK(aMGeom);
- vtkIdType aVNbNodes = VTKGeom2NbNodes(aVGeom);
+ VISU::EGeometry aEGeom = MEDGeom2VISU(aMGeom);
+ vtkIdType aVNbNodes = VISUGeom2NbNodes(aEGeom);
MED::PCellInfo aCellInfo = theMEDWrapper->GetPCellInfo(aMeshInfo,aMEntity,aMGeom);
TInt aNbElem = aCellInfo->GetNbElem();
aMeshOnEntity->myNbCells += aNbElem;
TGeom2SubProfile& aGeom2SubProfile = aProfile->myGeom2SubProfile;
TGeom2SubProfile::const_iterator anIter = aGeom2SubProfile.begin();
for(; anIter != aGeom2SubProfile.end(); anIter++){
- vtkIdType aVGeom = anIter->first;
+ VISU::EGeometry aEGeom = anIter->first;
PMEDSubProfile aSubProfile(anIter->second);
TInt aNbElem = aSubProfile->myNbCells;
- TInt aNbGauss = aValForTime->GetNbGauss(aVGeom);
+ TInt aNbGauss = aValForTime->GetNbGauss(aEGeom);
if(aSubProfile->myStatus != eRemoveAll){
INITMSG(MYTHREADDEBUG,
"- "<<this<<
- "; aVGeom = "<<aVGeom<<
+ "; aEGeom = "<<aEGeom<<
"; aNbElem = "<<aNbElem<<
"; aNbGauss = "<<aNbGauss<<
endl);
}
TGeom2SubMesh& aGeom2SubMesh = aMeshOnEntity->myGeom2SubMesh;
- PMEDSubMesh aSubMesh = aGeom2SubMesh[VTK_VERTEX](new TMEDSubMesh());
+ PMEDSubMesh aSubMesh = aGeom2SubMesh[VISU::ePOINT1](new TMEDSubMesh());
aSubMesh->Init(aNodeInfo);
aSubMesh->myNbCells = theMesh->myNbPoints;
if(aNbElem > 0){
TInt anId = theFamily->myId;
- TSubMeshID& aSubMeshID = theFamily->myGeom2SubMeshID[VTK_VERTEX];
+ TSubMeshID& aSubMeshID = theFamily->myGeom2SubMeshID[VISU::ePOINT1];
for(TInt iElem = 0; iElem < aNbElem; iElem++)
if(aNodeInfo->GetFamNum(iElem) == anId)
aSubMeshID.push_back(iElem);
for(; aGeom2SizeIter != aGeom2Size.end(); aGeom2SizeIter++){
const MED::EGeometrieElement& aMGeom = aGeom2SizeIter->first;
- vtkIdType aVGeom = MEDGeomToVTK(aMGeom);
+ VISU::EGeometry aEGeom = MEDGeom2VISU(aMGeom);
INITMSG(MYDEBUG,"aMGeom = "<<aMGeom<<"\n");
switch(aMGeom){
case MED::ePOLYGONE: {
MED::PPolygoneInfo aPolygoneInfo = theMed->GetPPolygoneInfo(aMeshInfo,aMEntity,aMGeom);
TInt aNbElem = aPolygoneInfo->GetNbElem();
if(aNbElem > 0){
- PMEDSubMesh aSubMesh = aGeom2SubMesh[aVGeom](new TMEDSubMesh());
+ PMEDSubMesh aSubMesh = aGeom2SubMesh[aEGeom](new TMEDSubMesh());
aSubMesh->Init(aPolygoneInfo);
aSubMesh->myNbCells = aNbElem;
TInt aNbElem = aPolyedreInfo->GetNbElem();
if(aNbElem > 0){
- PMEDSubMesh aSubMesh = aGeom2SubMesh[aVGeom](new TMEDSubMesh());
+ PMEDSubMesh aSubMesh = aGeom2SubMesh[aEGeom](new TMEDSubMesh());
aSubMesh->Init(aPolyedreInfo);
aSubMesh->myNbCells = aNbElem;
break;
}
default: {
- vtkIdType aVNbNodes = VTKGeom2NbNodes(aVGeom);
+ vtkIdType aVNbNodes = VISUGeom2NbNodes(aEGeom);
MED::PCellInfo aCellInfo = theMed->GetPCellInfo(aMeshInfo,aMEntity,aMGeom);
TInt aNbElem = aCellInfo->GetNbElem();
if(aNbElem > 0){
- PMEDSubMesh aSubMesh = aGeom2SubMesh[aVGeom](new TMEDSubMesh());
+ PMEDSubMesh aSubMesh = aGeom2SubMesh[aEGeom](new TMEDSubMesh());
aSubMesh->Init(aCellInfo);
aSubMesh->myNbCells = aNbElem;
}
switch(aMGeom){
+#ifndef VTK_QUADRATIC_EDGE && ENABLE_QUADRATIC
+ case MED::eSEG3:
+ anArray[0] = aConnect[0];
+ anArray[2] = aConnect[1];
+
+ anArray[1] = aConnect[2];
+ break;
+#endif
+#ifndef VTK_QUADRATIC_TRIANGLE && ENABLE_QUADRATIC
+ case MED::eTRIA6:
+ anArray[0] = aConnect[0];
+ anArray[2] = aConnect[1];
+ anArray[4] = aConnect[2];
+
+ anArray[1] = aConnect[3];
+ anArray[3] = aConnect[4];
+ anArray[5] = aConnect[5];
+ break;
+#endif
+#ifndef VTK_QUADRATIC_QUAD && ENABLE_QUADRATIC
+ case MED::eQUAD8:
+ anArray[0] = aConnect[0];
+ anArray[2] = aConnect[1];
+ anArray[4] = aConnect[2];
+ anArray[6] = aConnect[3];
+
+ anArray[1] = aConnect[4];
+ anArray[3] = aConnect[5];
+ anArray[5] = aConnect[6];
+ anArray[7] = aConnect[7];
+ break;
+#endif
+#ifdef VTK_QUADRATIC_TETRA && ENABLE_QUADRATIC
case MED::eTETRA10:
- anArray[4] = aConnect[4];
- anArray[5] = aConnect[5];
- anArray[6] = aConnect[7];
- anArray[7] = aConnect[6];
- anArray[8] = aConnect[8];
- anArray[9] = aConnect[9];
+#endif
case MED::eTETRA4:
anArray[0] = aConnect[0];
anArray[1] = aConnect[1];
anArray[2] = aConnect[3];
anArray[3] = aConnect[2];
break;
+#ifdef VTK_QUADRATIC_TETRA && ENABLE_QUADRATIC
case MED::ePYRA13:
- anArray[5] = aConnect[5];
- anArray[6] = aConnect[8];
- anArray[7] = aConnect[7];
- anArray[8] = aConnect[6];
- anArray[9] = aConnect[9];
- anArray[10] = aConnect[10];
- anArray[11] = aConnect[11];
- anArray[12] = aConnect[12];
+#endif
case MED::ePYRA5:
anArray[0] = aConnect[0];
anArray[1] = aConnect[3];
if(anElemInfo->GetFamNum(iElem) == anId)
aSubMeshID.push_back(iElem);
if(!aSubMeshID.empty()){
- TInt aVGeom = MEDGeomToVTK(aMGeom);
+ VISU::EGeometry aEGeom = MEDGeom2VISU(aMGeom);
INITMSG(MYDEBUG,"aMGeom = "<<aMGeom<<"\n");
- aGeom2SubMeshID.insert(TGeom2SubMeshID::value_type(aVGeom,aSubMeshID));
+ aGeom2SubMeshID.insert(TGeom2SubMeshID::value_type(aEGeom,aSubMeshID));
}
}
}
for(; anIter != aGeom2Profile.end(); anIter++){
MED::PProfileInfo aProfileInfo = anIter->second;
MED::EGeometrieElement aMGeom = anIter->first;
- vtkIdType aVGeom = MEDGeomToVTK(aMGeom);
+ VISU::EGeometry aEGeom = MEDGeom2VISU(aMGeom);
- TGeom2SubProfile::const_iterator anIter2 = aGeom2SubProfile.find(aVGeom);
+ TGeom2SubProfile::const_iterator anIter2 = aGeom2SubProfile.find(aEGeom);
if(anIter2 != aGeom2SubProfile.end()){
PMEDSubProfile aSubProfile = anIter2->second;
}
INITMSG(MYDEBUG,
- "- aVGeom = "<<aVGeom<<
+ "- aEGeom = "<<aEGeom<<
"; aNbCells = "<<aSubProfile->mySubMeshID.size()<<
endl);
}
TGeom2GaussSubMesh::const_iterator aSubMeshIter = aGeom2GaussSubMesh.begin();
for(; aSubMeshIter != aGeom2GaussSubMesh.end(); aSubMeshIter++){
PMEDGaussSubMesh aGaussSubMesh = aSubMeshIter->second;
- vtkIdType aVGeom = aSubMeshIter->first;
+ VISU::EGeometry aEGeom = aSubMeshIter->first;
if(aGaussSubMesh->myIsDone)
continue;
aGaussSubMesh->myIsDone = true;;
INITMSG(MYDEBUG,
- "- aVGeom = "<<aVGeom<<
+ "- aEGeom = "<<aEGeom<<
"; aName = '"<<aName<<"'"<<
"; aStatus = "<<aGaussSubMesh->myStatus<<
"; aNbCells = "<<aNbCells<<
const MED::TTimeStampVal& aTimeStampValRef = aTimeStampVal;
TGeom2SubProfile::const_iterator anIter = aGeom2SubProfile.begin();
for(; anIter != aGeom2SubProfile.end(); anIter++){
- vtkIdType aVGeom = anIter->first;
+ VISU::EGeometry aEGeom = anIter->first;
PMEDSubProfile aSubProfile(anIter->second);
TInt aNbElem = aSubProfile->myNbCells;
theField->myDataSize += aNbElem*aNbComp;
- TInt aNbGauss = theValForTime->GetNbGauss(aVGeom);
+ TInt aNbGauss = theValForTime->GetNbGauss(aEGeom);
if(aSubProfile->myStatus != eRemoveAll){
INITMSG(MYDEBUG,
- "- aVGeom = "<<aVGeom<<
+ "- aEGeom = "<<aEGeom<<
"; aNbElem = "<<aNbElem<<
"; aNbGauss = "<<aNbGauss<<
endl);
- TMeshValue& aVMeshValue = theValForTime->GetMeshValue(aVGeom);
+ TMeshValue& aVMeshValue = theValForTime->GetMeshValue(aEGeom);
aVMeshValue.Init(aNbElem,aNbGauss,aNbComp);
MED::EGeometrieElement aMGeom = aSubProfile->myMGeom;
//---------------------------------------------------------------
- int
- MEDGeomToVTK(medGeometryElement theMEDGeomType)
+ VISU::EGeometry
+ MEDGeom2VISU(medGeometryElement theGeom)
{
- switch(theMEDGeomType){
- case MED_NONE: return VTK_EMPTY_CELL;
- case MED_POINT1: return VTK_VERTEX;
- case MED_SEG2: return VTK_LINE;
- case MED_SEG3: return VTK_LINE;
- case MED_TRIA3: return VTK_TRIANGLE;
- case MED_TRIA6: return VTK_TRIANGLE;
- case MED_QUAD4: return VTK_QUAD;
- case MED_QUAD8: return VTK_QUAD;
- case MED_TETRA4: return VTK_TETRA;
- case MED_TETRA10: return VTK_TETRA;
- case MED_HEXA8: return VTK_HEXAHEDRON;
- case MED_HEXA20: return VTK_HEXAHEDRON;
- case MED_PENTA6: return VTK_WEDGE;
- case MED_PENTA15: return VTK_WEDGE;
- case MED_PYRA5: return VTK_PYRAMID;
- case MED_PYRA13: return VTK_PYRAMID;
+ switch(theGeom){
+ case MED_POINT1: return VISU::ePOINT1;
+ case MED_SEG2: return VISU::eSEG2;
+ case MED_SEG3: return VISU::eSEG3;
+ case MED_TRIA3: return VISU::eTRIA3;
+ case MED_TRIA6: return VISU::eTRIA6;
+ case MED_QUAD4: return VISU::eQUAD4;
+ case MED_QUAD8: return VISU::eQUAD8;
+ case MED_TETRA4: return VISU::eTETRA4;
+ case MED_TETRA10: return VISU::eTETRA10;
+ case MED_HEXA8: return VISU::eHEXA8;
+ case MED_HEXA20: return VISU::eHEXA20;
+ case MED_PENTA6: return VISU::ePENTA6;
+ case MED_PENTA15: return VISU::ePENTA15;
+ case MED_PYRA5: return VISU::ePYRA5;
+ case MED_PYRA13: return VISU::ePYRA13;
}
- return -1;
+ return VISU::eNONE;
}
if(MYDEBUG) MESSAGE("LoadPoints - Filling aMeshOnEntity with type NODE_ENTITY");
TGeom2SubMesh& aGeom2SubMesh = aMeshOnEntity->myGeom2SubMesh;
- PSubMeshImpl aSubMesh = aGeom2SubMesh[VTK_VERTEX];
+ PSubMeshImpl aSubMesh = aGeom2SubMesh[VISU::ePOINT1];
TCell2Connect& aCell2Connect = aSubMesh->myCell2Connect;
aCell2Connect.resize(aNbElem);
for(int iElem = 0; iElem < aNbElem; iElem++)
SALOME_MED::FAMILY_var aMedFamily = theFamily->myFamily;
CORBA::Boolean anIsOnAllElements = aMedFamily->isOnAllElements();
- TSubMeshID& aSubMeshID = theFamily->myGeom2SubMeshID[VTK_VERTEX];
+ TSubMeshID& aSubMeshID = theFamily->myGeom2SubMeshID[VISU::ePOINT1];
if(!anIsOnAllElements){
SALOME_MED::medGeometryElement_array_var aGeom = aMedFamily->getTypes();
int aNbPoints = aCoords.GetNbPoints();
for(int iGeom = 0, aCounter = 0; iGeom < iGeomEnd; iGeom++){
- SALOME_MED::medGeometryElement aGeom = aGeomElems[iGeom];
- int aMNbNodes = MEDGeom2NbNodes(aGeom);
- int aVGeom = MEDGeomToVTK(aGeom);
- int aVNbNodes = VTKGeom2NbNodes(aVGeom);
- int iNumElemEnd = aMedMesh->getNumberOfElements(aMEntity,aGeom);
+ SALOME_MED::medGeometryElement aMGeom = aGeomElems[iGeom];
+ int aMNbNodes = MEDGeom2NbNodes(aMGeom);
+ VISU::EGeometry aEGeom = MEDGeom2VISU(aEGeom);
+ int aVNbNodes = VISUGeom2NbNodes(aEGeom);
+ int iNumElemEnd = aMedMesh->getNumberOfElements(aMEntity,aMGeom);
if (iNumElemEnd > 0) {
+ using namespace SALOME_MED;
SALOME_MED::long_array_var conn =
- aMedMesh->getConnectivity(SALOME_MED::MED_FULL_INTERLACE,SALOME_MED::MED_NODAL,aMEntity,aGeom);
- PSubMeshImpl aSubMesh = aGeom2SubMesh[aVGeom];
+ aMedMesh->getConnectivity(MED_FULL_INTERLACE,MED_NODAL,aMEntity,aMGeom);
+ PSubMeshImpl aSubMesh = aGeom2SubMesh[aEGeom];
TCell2Connect& aCell2Connect = aSubMesh->myCell2Connect;
std::vector<int> aConnect(aMNbNodes);
int aNbConnForElem = conn->length()/iNumElemEnd;
- if(MYDEBUG) MESSAGE("LoadCellsOnEntity - aGeom = "<<aGeom<<
+ if(MYDEBUG) MESSAGE("LoadCellsOnEntity - aMGeom = "<<aMGeom<<
"; iNumElemEnd = "<<iNumElemEnd<<
"; aNbConnForElem = "<<aNbConnForElem);
for(int k = 0, kj = iNumElem*aNbConnForElem; k < aMNbNodes; k++)
aConnect[k] = conn[kj+k] - 1;
- switch(aGeom){
+ switch(aMGeom){
+ case SALOME_MED::MED_SEG3:
+ anArray[0] = aConnect[0];
+ anArray[2] = aConnect[1];
+
+ anArray[1] = aConnect[2];
+ break;
+ case SALOME_MED::MED_TRIA6:
+ anArray[0] = aConnect[0];
+ anArray[2] = aConnect[1];
+ anArray[4] = aConnect[2];
+
+ anArray[1] = aConnect[3];
+ anArray[3] = aConnect[4];
+ anArray[5] = aConnect[5];
+ break;
+ case SALOME_MED::MED_QUAD8:
+ anArray[0] = aConnect[0];
+ anArray[2] = aConnect[1];
+ anArray[4] = aConnect[2];
+ anArray[6] = aConnect[3];
+
+ anArray[1] = aConnect[4];
+ anArray[3] = aConnect[5];
+ anArray[5] = aConnect[6];
+ anArray[7] = aConnect[7];
+ break;
case SALOME_MED::MED_TETRA4 :
- case SALOME_MED::MED_TETRA10 :
anArray[0] = aConnect[0];
anArray[1] = aConnect[1];
anArray[2] = aConnect[3];
anArray[3] = aConnect[2];
break;
- case SALOME_MED::MED_PYRA5 :
case SALOME_MED::MED_PYRA13 :
anArray[0] = aConnect[0];
anArray[1] = aConnect[3];
}
//Workaround for MED Component data structure
int aSize = aCell2Connect.size();
- theMeshOnEntity->myCellsFirstIndex[aGeom] = TCMeshOnEntity::TIndexAndSize(aCounter,aSize);
+ theMeshOnEntity->myCellsFirstIndex[aMGeom] = TCMeshOnEntity::TIndexAndSize(aCounter,aSize);
aCounter += aSize;
}
}
int iGeomEnd = aGeoms->length();
if(MYDEBUG) MESSAGE("LoadCellsOnEntity - iGeomEnd = "<<iGeomEnd);
for(int iGeom = 0; iGeom < iGeomEnd; iGeom++){
- SALOME_MED::medGeometryElement aGeom = aGeoms[iGeom];
- SALOME_MED::long_array_var aCellNumForType = aMedFamily->getNumber(aGeom);
- int aVGeom = MEDGeomToVTK(aGeom);
+ SALOME_MED::medGeometryElement aMGeom = aGeoms[iGeom];
+ SALOME_MED::long_array_var aCellNumForType = aMedFamily->getNumber(aMGeom);
+ VISU::EGeometry aEGeom = MEDGeom2VISU(aMGeom);
int iNumElemEndTmp = 0;
- TGeom2SubMesh::const_iterator anIter = aGeom2SubMesh.find(aVGeom);
+ TGeom2SubMesh::const_iterator anIter = aGeom2SubMesh.find(aEGeom);
if(anIter != aGeom2SubMesh.end()){
const VISU::TSubMeshImpl& aSubMesh = anIter->second;
const VISU::TCell2Connect& anArray = aSubMesh.myCell2Connect;
iNumElemEndTmp = anArray.size();
}
- TSubMeshID& aSubMeshID = theFamily->myGeom2SubMeshID[aVGeom];
+ TSubMeshID& aSubMeshID = theFamily->myGeom2SubMeshID[aEGeom];
int iNumElemEnd = aCellNumForType->length();
- int aCounter = theMeshOnEntity->myCellsFirstIndex[aGeom].first;
+ int aCounter = theMeshOnEntity->myCellsFirstIndex[aMGeom].first;
if(MYDEBUG)
MESSAGE("LoadCellsOnFamily "<<
- "- aGeom = "<<aGeom<<
+ "- aMGeom = "<<aMGeom<<
"; iNumElemEnd = "<<iNumElemEnd<<
"; aCounter = "<<aCounter);
const VISU::TGeom2SubMesh& aGeom2SubMesh = theMeshOnEntity->myGeom2SubMesh;
VISU::TGeom2SubMesh::const_iterator anIter = aGeom2SubMesh.begin();
for(; anIter != aGeom2SubMesh.end(); anIter++){
- int aVGeom = anIter->first;
+ VISU::EGeometry aEGeom = anIter->first;
const VISU::TSubMeshImpl& aSubMesh = anIter->second;
const VISU::TCell2Connect& aCell2Connect = aSubMesh.myCell2Connect;
- TSubMeshID& aSubMeshID = theFamily->myGeom2SubMeshID[aVGeom];
+ TSubMeshID& aSubMeshID = theFamily->myGeom2SubMeshID[aEGeom];
int iNumElemEnd = aCell2Connect.size();
for(int iNumElem = 0; iNumElem < iNumElemEnd; iNumElem++)
aSubMeshID.push_back(iNumElem);
{
int aNbComp = theField->myNbComp;
if(theField->myEntity == NODE_ENTITY){
- int aVGeom = VTK_VERTEX;
- int aNbGauss = theValForTime->GetNbGauss(aVGeom);
+ VISU::EGeometry aEGeom = VISU::ePOINT1;
+ int aNbGauss = theValForTime->GetNbGauss(aEGeom);
const TNamedPointCoords& aCoords = theMesh->myNamedPointCoords;
int aNbPoints = aCoords.GetNbPoints();
int aNbElem = aNbPoints*aNbComp;
if(MYDEBUG) MESSAGE("ImportField - aNbElem = "<<aNbElem);
- TMeshValue& aMeshValue = theValForTime->GetMeshValue(VTK_VERTEX);
+ TMeshValue& aMeshValue = theValForTime->GetMeshValue(VISU::ePOINT1);
aMeshValue.Init(aNbElem,aNbGauss,aNbComp);
for(int iElem = 0, anId = 0; iElem < aNbElem; iElem++){
TValueSliceArr aValueSliceArr = aMeshValue.GetGaussValueSliceArr(iElem);
const TEntity& aVEntity = theField->myEntity;
int iGeomEnd = GetEntity2Geom(aVEntity,aGeomElems);
for(int iGeom = 0; iGeom < iGeomEnd; iGeom++){
- SALOME_MED::medGeometryElement aGeom = aGeomElems[iGeom];
- int aVGeom = MEDGeomToVTK(aGeom);
- int aNbGauss = theValForTime->GetNbGauss(aVGeom);
+ SALOME_MED::medGeometryElement aMGeom = aGeomElems[iGeom];
+ VISU::EGeometry aEGeom = MEDGeom2VISU(aMGeom);
+ int aNbGauss = theValForTime->GetNbGauss(aEGeom);
const TCMeshOnEntity::TCellsFirstIndex& aCellsFirstIndex = theMeshOnEntity->myCellsFirstIndex;
- TCMeshOnEntity::TCellsFirstIndex::const_iterator aCellsFirstIndexIter = aCellsFirstIndex.find(aGeom);
+ TCMeshOnEntity::TCellsFirstIndex::const_iterator aCellsFirstIndexIter = aCellsFirstIndex.find(aMGeom);
if(aCellsFirstIndexIter != aCellsFirstIndex.end()){
const TCMeshOnEntity::TIndexAndSize& aIndexAndSize = aCellsFirstIndexIter->second;
if(MYDEBUG)
- MESSAGE("ImportField - aGeom = "<<aGeom<<
+ MESSAGE("ImportField - aMGeom = "<<aMGeom<<
"; aIndexAndSize = {"<<aIndexAndSize.first<<
","<<aIndexAndSize.second<<"}");
int aNbElem = aIndexAndSize.second;
int aStart = aIndexAndSize.first*aNbComp;
- TMeshValue& aMeshValue = theValForTime->GetMeshValue(aVGeom);
+ TMeshValue& aMeshValue = theValForTime->GetMeshValue(aEGeom);
aMeshValue.Init(aNbElem,aNbGauss,aNbComp);
for(int iElem = 0, anId = 0; iElem < aNbElem; iElem++, anId += aNbComp){
TValueSliceArr aValueSliceArr = aMeshValue.GetGaussValueSliceArr(iElem);
