#include <DriverMED_W_SMESHDS_Mesh.h>
Inheritance diagram for DriverMED_W_SMESHDS_Mesh:
Public Types | |
| enum | Status { DRS_OK, DRS_EMPTY, DRS_WARN_RENUMBER, DRS_WARN_SKIP_ELEM, DRS_FAIL } |
Public Member Functions | |
| DriverMED_W_SMESHDS_Mesh () | |
| virtual void | SetFile (const std::string &theFileName) |
| void | SetFile (const std::string &theFileName, MED::EVersion theId) |
| void | AddGroupOfNodes () |
| sets file name; only for usage with Add(), not Write() | |
| void | AddGroupOfEdges () |
| void | AddGroupOfFaces () |
| void | AddGroupOfVolumes () |
| void | SetMeshName (const std::string &theMeshName) |
| functions to prepare adding one mesh | |
| void | AddGroup (SMESHDS_GroupBase *theGroup) |
| void | AddAllSubMeshes () |
| void | AddSubMesh (SMESHDS_SubMesh *theSubMesh, int theID) |
| virtual Status | Perform () |
| add one mesh | |
| void | SetMesh (SMESHDS_Mesh *theMesh) |
| void | SetMeshId (int theMeshId) |
Static Public Member Functions | |
| static std::string | GetVersionString (const MED::EVersion theVersion, int theNbDigits=2) |
Protected Attributes | |
| SMESHDS_Mesh * | myMesh |
| std::string | myFile |
| int | myMeshId |
Private Attributes | |
| MED::PWrapper | myMed |
| std::string | myMeshName |
| std::list< SMESHDS_GroupBase * > | myGroups |
| bool | myAllSubMeshes |
| std::map< int, SMESHDS_SubMesh * > | mySubMeshes |
| bool | myDoGroupOfNodes |
| bool | myDoGroupOfEdges |
| bool | myDoGroupOfFaces |
| bool | myDoGroupOfVolumes |
Detailed Description
Definition at line 43 of file DriverMED_W_SMESHDS_Mesh.h.
Member Enumeration Documentation
enum Driver_Mesh::Status [inherited] |
Definition at line 48 of file Driver_Mesh.h.
{
DRS_OK,
DRS_EMPTY, // a file contains no mesh with the given name
DRS_WARN_RENUMBER, // a file has overlapped ranges of element numbers,
// so the numbers from the file are ignored
DRS_WARN_SKIP_ELEM, // some elements were skipped due to incorrect file data
DRS_FAIL // general failure (exception etc.)
};
Constructor & Destructor Documentation
| DriverMED_W_SMESHDS_Mesh::DriverMED_W_SMESHDS_Mesh | ( | ) |
Definition at line 49 of file DriverMED_W_SMESHDS_Mesh.cxx.
: myAllSubMeshes (false), myDoGroupOfNodes (false), myDoGroupOfEdges (false), myDoGroupOfFaces (false), myDoGroupOfVolumes (false) {}
Member Function Documentation
| void DriverMED_W_SMESHDS_Mesh::AddAllSubMeshes | ( | ) |
Definition at line 97 of file DriverMED_W_SMESHDS_Mesh.cxx.
References myAllSubMeshes.
{
myAllSubMeshes = true;
}
| void DriverMED_W_SMESHDS_Mesh::AddGroup | ( | SMESHDS_GroupBase * | theGroup | ) |
Definition at line 92 of file DriverMED_W_SMESHDS_Mesh.cxx.
References myGroups.
{
myGroups.push_back(theGroup);
}
| void DriverMED_W_SMESHDS_Mesh::AddGroupOfEdges | ( | ) |
Definition at line 112 of file DriverMED_W_SMESHDS_Mesh.cxx.
References myDoGroupOfEdges.
{
myDoGroupOfEdges = true;
}
| void DriverMED_W_SMESHDS_Mesh::AddGroupOfFaces | ( | ) |
Definition at line 117 of file DriverMED_W_SMESHDS_Mesh.cxx.
References myDoGroupOfFaces.
{
myDoGroupOfFaces = true;
}
| void DriverMED_W_SMESHDS_Mesh::AddGroupOfNodes | ( | ) |
sets file name; only for usage with Add(), not Write()
Definition at line 107 of file DriverMED_W_SMESHDS_Mesh.cxx.
References myDoGroupOfNodes.
{
myDoGroupOfNodes = true;
}
| void DriverMED_W_SMESHDS_Mesh::AddGroupOfVolumes | ( | ) |
Definition at line 122 of file DriverMED_W_SMESHDS_Mesh.cxx.
References myDoGroupOfVolumes.
{
myDoGroupOfVolumes = true;
}
| void DriverMED_W_SMESHDS_Mesh::AddSubMesh | ( | SMESHDS_SubMesh * | theSubMesh, |
| int | theID | ||
| ) |
Definition at line 102 of file DriverMED_W_SMESHDS_Mesh.cxx.
References mySubMeshes.
{
mySubMeshes[theID] = theSubMesh;
}
| string DriverMED_W_SMESHDS_Mesh::GetVersionString | ( | const MED::EVersion | theVersion, |
| int | theNbDigits = 2 |
||
| ) | [static] |
Definition at line 69 of file DriverMED_W_SMESHDS_Mesh.cxx.
References ex21_lamp.name.
{
TInt majeur, mineur, release;
majeur = mineur = release = 0;
// if ( theVersion == eV2_1 )
// MED::GetVersionRelease<eV2_1>(majeur, mineur, release);
// else
MED::GetVersionRelease<eV2_2>(majeur, mineur, release);
ostringstream name;
if ( theNbDigits > 0 )
name << majeur;
if ( theNbDigits > 1 )
name << "." << mineur;
if ( theNbDigits > 2 )
name << "." << release;
return name.str();
}
| Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform | ( | ) | [virtual] |
add one mesh
Implements Driver_Mesh.
Definition at line 327 of file DriverMED_W_SMESHDS_Mesh.cxx.
References Driver_Mesh.DRS_FAIL, Driver_Mesh.DRS_OK, SMDS_Mesh.edgesIterator(), SMDS_Mesh.elements0dIterator(), ex21_lamp.faces, SMDS_Mesh.facesIterator(), SMDS_MeshElement.GetID(), SMDS_Mesh.GetMeshInfo(), SMDS_MeshElement.GetNode(), SMDS_Mesh.hasConstructionEdges(), SMDS_Mesh.hasConstructionFaces(), SMDS_VtkVolume.IsPoly(), DriverMED_Family.MakeFamilies(), MESSAGE, myAllSubMeshes, myDoGroupOfEdges, myDoGroupOfFaces, myDoGroupOfNodes, myDoGroupOfVolumes, Driver_Mesh.myFile, myGroups, myMed, Driver_SMESHDS_Mesh.myMesh, Driver_Mesh.myMeshId, myMeshName, mySubMeshes, SMDS_MeshInfo.Nb0DElements(), SMDS_MeshInfo.NbEdges(), SMDS_Mesh.NbEdges(), SMDS_VtkVolume.NbFaceNodes(), SMDS_VtkVolume.NbFaces(), SMDS_Mesh.NbFaces(), SMDS_MeshInfo.NbHexas(), SMDS_VtkVolume.NbNodes(), SMDS_Mesh.NbNodes(), SMDS_MeshInfo.NbPolygons(), SMDS_MeshInfo.NbPolyhedrons(), SMDS_MeshInfo.NbPrisms(), SMDS_MeshInfo.NbPyramids(), SMDS_MeshInfo.NbQuadrangles(), SMDS_MeshInfo.NbTetras(), SMDS_MeshInfo.NbTriangles(), SMDS_Mesh.NbVolumes(), SMDS_Mesh.nodesIterator(), ORDER_LINEAR, ORDER_QUADRATIC, REST_EDGES_FAMILY, REST_FACES_FAMILY, REST_NODES_FAMILY, REST_VOLUMES_FAMILY, SMDSAbs_0DElement, SMDSAbs_Edge, SMDSAbs_Face, SMDSAbs_NbElementTypes, SMDSAbs_Node, SMDSAbs_Volume, SMESHDS_Mesh.SubMeshes(), SMDS_Mesh.volumesIterator(), SMDS_MeshNode.X(), SMDS_MeshNode.Y(), and SMDS_MeshNode.Z().
{
Status aResult = DRS_OK;
if (myMesh->hasConstructionEdges() || myMesh->hasConstructionFaces()) {
INFOS("SMDS_MESH with hasConstructionEdges() or hasConstructionFaces() do not supports!!!");
return DRS_FAIL;
}
try {
MESSAGE("Perform - myFile : "<<myFile);
// Creating the MED mesh for corresponding SMDS structure
//-------------------------------------------------------
string aMeshName;
if (myMeshId != -1) {
ostringstream aMeshNameStr;
aMeshNameStr<<myMeshId;
aMeshName = aMeshNameStr.str();
} else {
aMeshName = myMeshName;
}
// Mesh dimension definition
TInt aSpaceDimension;
TCoordHelperPtr aCoordHelperPtr;
{
bool anIsXDimension = false;
bool anIsYDimension = false;
bool anIsZDimension = false;
{
SMDS_NodeIteratorPtr aNodesIter = myMesh->nodesIterator();
double aBounds[6];
if(aNodesIter->more()){
const SMDS_MeshNode* aNode = aNodesIter->next();
aBounds[0] = aBounds[1] = aNode->X();
aBounds[2] = aBounds[3] = aNode->Y();
aBounds[4] = aBounds[5] = aNode->Z();
}
while(aNodesIter->more()){
const SMDS_MeshNode* aNode = aNodesIter->next();
aBounds[0] = min(aBounds[0],aNode->X());
aBounds[1] = max(aBounds[1],aNode->X());
aBounds[2] = min(aBounds[2],aNode->Y());
aBounds[3] = max(aBounds[3],aNode->Y());
aBounds[4] = min(aBounds[4],aNode->Z());
aBounds[5] = max(aBounds[5],aNode->Z());
}
double EPS = 1.0E-7;
anIsXDimension = (aBounds[1] - aBounds[0]) + abs(aBounds[1]) + abs(aBounds[0]) > EPS;
anIsYDimension = (aBounds[3] - aBounds[2]) + abs(aBounds[3]) + abs(aBounds[2]) > EPS;
anIsZDimension = (aBounds[5] - aBounds[4]) + abs(aBounds[5]) + abs(aBounds[4]) > EPS;
aSpaceDimension = anIsXDimension + anIsYDimension + anIsZDimension;
if(!aSpaceDimension)
aSpaceDimension = 3;
// PAL16857(SMESH not conform to the MED convention):
if ( aSpaceDimension == 2 && anIsZDimension ) // 2D only if mesh is in XOY plane
aSpaceDimension = 3;
// PAL18941(a saved study with a mesh belong Z is opened and the mesh is belong X)
if ( aSpaceDimension == 1 && !anIsXDimension ) {// 1D only if mesh is along OX
if ( anIsYDimension ) {
aSpaceDimension = 2;
anIsXDimension = true;
} else {
aSpaceDimension = 3;
}
}
}
SMDS_NodeIteratorPtr aNodesIter = myMesh->nodesIterator(/*idInceasingOrder=*/true);
switch(aSpaceDimension){
case 3:
aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aXYZGetCoord,aXYZName));
break;
case 2:
if(anIsXDimension && anIsYDimension)
aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aXYGetCoord,aXYName));
if(anIsYDimension && anIsZDimension)
aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aYZGetCoord,aYZName));
if(anIsXDimension && anIsZDimension)
aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aXZGetCoord,aXZName));
break;
case 1:
if(anIsXDimension)
aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aXGetCoord,aXName));
if(anIsYDimension)
aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aYGetCoord,aYName));
if(anIsZDimension)
aCoordHelperPtr.reset(new TCoordHelper(aNodesIter,aZGetCoord,aZName));
break;
}
}
TInt aMeshDimension = 0;
if ( myMesh->NbEdges() > 0 )
aMeshDimension = 1;
if ( myMesh->NbFaces() > 0 )
aMeshDimension = 2;
if ( myMesh->NbVolumes() > 0 )
aMeshDimension = 3;
PMeshInfo aMeshInfo = myMed->CrMeshInfo(aMeshDimension,aSpaceDimension,aMeshName);
MESSAGE("Add - aMeshName : "<<aMeshName<<"; "<<aMeshInfo->GetName());
myMed->SetMeshInfo(aMeshInfo);
// Storing SMDS groups and sub-meshes as med families
//----------------------------------------------------
int myNodesDefaultFamilyId = 0;
int my0DElementsDefaultFamilyId = 0;
int myEdgesDefaultFamilyId = 0;
int myFacesDefaultFamilyId = 0;
int myVolumesDefaultFamilyId = 0;
int nbNodes = myMesh->NbNodes();
//int nb0DElements = myMesh->Nb0DElements();
int nbEdges = myMesh->NbEdges();
int nbFaces = myMesh->NbFaces();
int nbVolumes = myMesh->NbVolumes();
if (myDoGroupOfNodes && nbNodes)
myNodesDefaultFamilyId = REST_NODES_FAMILY;
if (myDoGroupOfEdges && nbEdges)
myEdgesDefaultFamilyId = REST_EDGES_FAMILY;
if (myDoGroupOfFaces && nbFaces)
myFacesDefaultFamilyId = REST_FACES_FAMILY;
if (myDoGroupOfVolumes && nbVolumes)
myVolumesDefaultFamilyId = REST_VOLUMES_FAMILY;
MESSAGE("Perform - aFamilyInfo");
//cout << " DriverMED_Family::MakeFamilies() " << endl;
list<DriverMED_FamilyPtr> aFamilies;
if (myAllSubMeshes) {
aFamilies = DriverMED_Family::MakeFamilies
(myMesh->SubMeshes(), myGroups,
myDoGroupOfNodes && nbNodes,
myDoGroupOfEdges && nbEdges,
myDoGroupOfFaces && nbFaces,
myDoGroupOfVolumes && nbVolumes);
} else {
aFamilies = DriverMED_Family::MakeFamilies
(mySubMeshes, myGroups,
myDoGroupOfNodes && nbNodes,
myDoGroupOfEdges && nbEdges,
myDoGroupOfFaces && nbFaces,
myDoGroupOfVolumes && nbVolumes);
}
//cout << " myMed->SetFamilyInfo() " << endl;
list<DriverMED_FamilyPtr>::iterator aFamsIter;
for (aFamsIter = aFamilies.begin(); aFamsIter != aFamilies.end(); aFamsIter++)
{
PFamilyInfo aFamilyInfo = (*aFamsIter)->GetFamilyInfo(myMed,aMeshInfo);
myMed->SetFamilyInfo(aFamilyInfo);
}
// Storing SMDS nodes to the MED file for the MED mesh
//----------------------------------------------------
#ifdef _EDF_NODE_IDS_
typedef map<TInt,TInt> TNodeIdMap;
TNodeIdMap aNodeIdMap;
#endif
const EModeSwitch theMode = eFULL_INTERLACE;
const ERepere theSystem = eCART;
const EBooleen theIsElemNum = eVRAI;
const EBooleen theIsElemNames = eFAUX;
const EConnectivite theConnMode = eNOD;
TInt aNbNodes = myMesh->NbNodes();
//cout << " myMed->CrNodeInfo() aNbNodes = " << aNbNodes << endl;
PNodeInfo aNodeInfo = myMed->CrNodeInfo(aMeshInfo, aNbNodes,
theMode, theSystem, theIsElemNum, theIsElemNames);
//cout << " fillElemFamilyMap( SMDSAbs_Node )" << endl;
// find family numbers for nodes
TElemFamilyMap anElemFamMap;
fillElemFamilyMap( anElemFamMap, aFamilies, SMDSAbs_Node );
for (TInt iNode = 0; aCoordHelperPtr->Next(); iNode++)
{
// coordinates
TCoordSlice aTCoordSlice = aNodeInfo->GetCoordSlice( iNode );
for(TInt iCoord = 0; iCoord < aSpaceDimension; iCoord++){
aTCoordSlice[iCoord] = aCoordHelperPtr->GetCoord(iCoord);
}
// node number
int aNodeID = aCoordHelperPtr->GetID();
aNodeInfo->SetElemNum( iNode, aNodeID );
#ifdef _EDF_NODE_IDS_
aNodeIdMap[aNodeID] = iNode+1;
#endif
// family number
const SMDS_MeshNode* aNode = aCoordHelperPtr->GetNode();
int famNum = getFamilyId( anElemFamMap, aNode, myNodesDefaultFamilyId );
aNodeInfo->SetFamNum( iNode, famNum );
}
anElemFamMap.Clear();
// coordinate names and units
for (TInt iCoord = 0; iCoord < aSpaceDimension; iCoord++) {
aNodeInfo->SetCoordName( iCoord, aCoordHelperPtr->GetName(iCoord));
aNodeInfo->SetCoordUnit( iCoord, aCoordHelperPtr->GetUnit(iCoord));
}
//cout << " SetNodeInfo(aNodeInfo)" << endl;
MESSAGE("Perform - aNodeInfo->GetNbElem() = "<<aNbNodes);
myMed->SetNodeInfo(aNodeInfo);
aNodeInfo.reset(); // free memory used for arrays
// Storing SMDS elements to the MED file for the MED mesh
//-------------------------------------------------------
// Write one element type at once in order to minimize memory usage (PAL19276)
const SMDS_MeshInfo& nbElemInfo = myMesh->GetMeshInfo();
// poly elements are not supported by med-2.1
bool polyTypesSupported = myMed->CrPolygoneInfo(aMeshInfo,eMAILLE,ePOLYGONE,0,0);
TInt nbPolygonNodes = 0, nbPolyhedronNodes = 0, nbPolyhedronFaces = 0;
// collect info on all geom types
list< TElemTypeData > aTElemTypeDatas;
EEntiteMaillage anEntity = eMAILLE;
#ifdef _ELEMENTS_BY_DIM_
anEntity = eNOEUD_ELEMENT;
#endif
aTElemTypeDatas.push_back(TElemTypeData(anEntity,
ePOINT1,
nbElemInfo.Nb0DElements(),
SMDSAbs_0DElement));
#ifdef _ELEMENTS_BY_DIM_
anEntity = eARETE;
#endif
aTElemTypeDatas.push_back( TElemTypeData(anEntity,
eSEG2,
nbElemInfo.NbEdges( ORDER_LINEAR ),
SMDSAbs_Edge));
aTElemTypeDatas.push_back( TElemTypeData(anEntity,
eSEG3,
nbElemInfo.NbEdges( ORDER_QUADRATIC ),
SMDSAbs_Edge));
#ifdef _ELEMENTS_BY_DIM_
anEntity = eFACE;
#endif
aTElemTypeDatas.push_back( TElemTypeData(anEntity,
eTRIA3,
nbElemInfo.NbTriangles( ORDER_LINEAR ),
SMDSAbs_Face));
aTElemTypeDatas.push_back( TElemTypeData(anEntity,
eTRIA6,
nbElemInfo.NbTriangles( ORDER_QUADRATIC ),
SMDSAbs_Face));
aTElemTypeDatas.push_back( TElemTypeData(anEntity,
eQUAD4,
nbElemInfo.NbQuadrangles( ORDER_LINEAR ),
SMDSAbs_Face));
aTElemTypeDatas.push_back( TElemTypeData(anEntity,
eQUAD8,
nbElemInfo.NbQuadrangles( ORDER_QUADRATIC ),
SMDSAbs_Face));
if ( polyTypesSupported ) {
aTElemTypeDatas.push_back( TElemTypeData(anEntity,
ePOLYGONE,
nbElemInfo.NbPolygons(),
SMDSAbs_Face));
// we need one more loop on poly elements to count nb of their nodes
aTElemTypeDatas.push_back( TElemTypeData(anEntity,
ePOLYGONE,
nbElemInfo.NbPolygons(),
SMDSAbs_Face));
}
#ifdef _ELEMENTS_BY_DIM_
anEntity = eMAILLE;
#endif
aTElemTypeDatas.push_back( TElemTypeData(anEntity,
eTETRA4,
nbElemInfo.NbTetras( ORDER_LINEAR ),
SMDSAbs_Volume));
aTElemTypeDatas.push_back( TElemTypeData(anEntity,
eTETRA10,
nbElemInfo.NbTetras( ORDER_QUADRATIC ),
SMDSAbs_Volume));
aTElemTypeDatas.push_back( TElemTypeData(anEntity,
ePYRA5,
nbElemInfo.NbPyramids( ORDER_LINEAR ),
SMDSAbs_Volume));
aTElemTypeDatas.push_back( TElemTypeData(anEntity,
ePYRA13,
nbElemInfo.NbPyramids( ORDER_QUADRATIC ),
SMDSAbs_Volume));
aTElemTypeDatas.push_back( TElemTypeData(anEntity,
ePENTA6,
nbElemInfo.NbPrisms( ORDER_LINEAR ),
SMDSAbs_Volume));
aTElemTypeDatas.push_back( TElemTypeData(anEntity,
ePENTA15,
nbElemInfo.NbPrisms( ORDER_QUADRATIC ),
SMDSAbs_Volume));
aTElemTypeDatas.push_back( TElemTypeData(anEntity,
eHEXA8,
nbElemInfo.NbHexas( ORDER_LINEAR ),
SMDSAbs_Volume));
aTElemTypeDatas.push_back( TElemTypeData(anEntity,
eHEXA20,
nbElemInfo.NbHexas( ORDER_QUADRATIC ),
SMDSAbs_Volume));
if ( polyTypesSupported ) {
//MESSAGE("polyTypesSupported");
aTElemTypeDatas.push_back( TElemTypeData(anEntity,
ePOLYEDRE,
nbElemInfo.NbPolyhedrons(),
SMDSAbs_Volume));
// we need one more loop on poly elements to count nb of their nodes
aTElemTypeDatas.push_back( TElemTypeData(anEntity,
ePOLYEDRE,
nbElemInfo.NbPolyhedrons(),
SMDSAbs_Volume));
}
vector< bool > isElemFamMapBuilt( SMDSAbs_NbElementTypes, false );
// loop on all geom types of elements
list< TElemTypeData >::iterator aElemTypeData = aTElemTypeDatas.begin();
for ( ; aElemTypeData != aTElemTypeDatas.end(); ++aElemTypeData )
{
if ( aElemTypeData->_nbElems == 0 )
continue;
// iterator on elements of a current type
PElemIterator elemIterator;
int defaultFamilyId = 0;
switch ( aElemTypeData->_smdsType ) {
case SMDSAbs_0DElement:
elemIterator = PElemIterator( new T0DElementIterator( myMesh->elements0dIterator() ));
defaultFamilyId = my0DElementsDefaultFamilyId;
break;
case SMDSAbs_Edge:
elemIterator = PElemIterator( new TEdgeIterator( myMesh->edgesIterator() ));
defaultFamilyId = myEdgesDefaultFamilyId;
break;
case SMDSAbs_Face:
elemIterator = PElemIterator( new TFaceIterator( myMesh->facesIterator() ));
defaultFamilyId = myFacesDefaultFamilyId;
break;
case SMDSAbs_Volume:
elemIterator = PElemIterator( new TVolumeIterator( myMesh->volumesIterator() ));
defaultFamilyId = myVolumesDefaultFamilyId;
break;
default:
continue;
}
int iElem = 0;
//cout << " Treat type " << aElemTypeData->_geomType << " nb = " <<aElemTypeData->_nbElems<< endl;
// Treat POLYGONs
// ---------------
if ( aElemTypeData->_geomType == ePOLYGONE )
{
if ( nbPolygonNodes == 0 ) {
// Count nb of nodes
while ( const SMDS_MeshElement* anElem = elemIterator->next() ) {
if ( anElem->IsPoly() ) {
nbPolygonNodes += anElem->NbNodes();
if ( ++iElem == aElemTypeData->_nbElems )
break;
}
}
}
else {
// Store in med file
PPolygoneInfo aPolygoneInfo = myMed->CrPolygoneInfo(aMeshInfo,
aElemTypeData->_entity,
aElemTypeData->_geomType,
aElemTypeData->_nbElems,
nbPolygonNodes,
theConnMode, theIsElemNum,
theIsElemNames);
TElemNum & index = *(aPolygoneInfo->myIndex.get());
index[0] = 1;
while ( const SMDS_MeshElement* anElem = elemIterator->next() )
{
if ( !anElem->IsPoly() )
continue;
// index
TInt aNbNodes = anElem->NbNodes();
index[ iElem+1 ] = index[ iElem ] + aNbNodes;
// connectivity
TConnSlice aTConnSlice = aPolygoneInfo->GetConnSlice( iElem );
for(TInt iNode = 0; iNode < aNbNodes; iNode++) {
const SMDS_MeshElement* aNode = anElem->GetNode( iNode );
#ifdef _EDF_NODE_IDS_
aTConnSlice[ iNode ] = aNodeIdMap[aNode->GetID()];
#else
aTConnSlice[ iNode ] = aNode->GetID();
#endif
}
// element number
aPolygoneInfo->SetElemNum( iElem, anElem->GetID() );
// family number
int famNum = getFamilyId( anElemFamMap, anElem, defaultFamilyId );
aPolygoneInfo->SetFamNum( iElem, famNum );
if ( ++iElem == aPolygoneInfo->GetNbElem() )
break;
}
// if(TInt aNbElems = aPolygoneElemNums.size())
// // add one element in connectivities,
// // referenced by the last element in indices
// aPolygoneConn.push_back(0);
//cout << " SetPolygoneInfo(aPolygoneInfo)" << endl;
myMed->SetPolygoneInfo(aPolygoneInfo);
}
}
// Treat POLYEDREs
// ----------------
else if (aElemTypeData->_geomType == ePOLYEDRE )
{
//MESSAGE("_geomType == ePOLYEDRE");
if ( nbPolyhedronNodes == 0 ) {
// Count nb of nodes
while ( const SMDS_MeshElement* anElem = elemIterator->next() ) {
const SMDS_VtkVolume *aPolyedre = dynamic_cast<const SMDS_VtkVolume*>(anElem);
if ( aPolyedre && aPolyedre->IsPoly()) {
nbPolyhedronNodes += aPolyedre->NbNodes();
nbPolyhedronFaces += aPolyedre->NbFaces();
if ( ++iElem == aElemTypeData->_nbElems )
break;
}
}
//MESSAGE("nbPolyhedronNodes=" << nbPolyhedronNodes);
//MESSAGE("nbPolyhedronFaces=" << nbPolyhedronFaces);
//MESSAGE("_nbElems="<< aElemTypeData->_nbElems);
}
else {
// Store in med file
PPolyedreInfo aPolyhInfo = myMed->CrPolyedreInfo(aMeshInfo,
aElemTypeData->_entity,
aElemTypeData->_geomType,
aElemTypeData->_nbElems,
nbPolyhedronFaces+1,
nbPolyhedronNodes,
theConnMode,
theIsElemNum,
theIsElemNames);
TElemNum & index = *(aPolyhInfo->myIndex.get());
TElemNum & faces = *(aPolyhInfo->myFaces.get());
TElemNum & conn = *(aPolyhInfo->myConn.get());
index[0] = 1;
faces[0] = 1;
TInt iFace = 0, iNode = 0;
while ( const SMDS_MeshElement* anElem = elemIterator->next() )
{
const SMDS_VtkVolume *aPolyedre = dynamic_cast<const SMDS_VtkVolume*>(anElem);
if ( !aPolyedre )
continue;
if ( !aPolyedre->IsPoly() )
continue;
//MESSAGE("index[" << iElem << "]=" << index[iElem] << " iElem=" << iElem);
// index
TInt aNbFaces = aPolyedre->NbFaces();
index[ iElem+1 ] = index[ iElem ] + aNbFaces;
//MESSAGE("index[" << iElem+1 << "]=" << index[iElem+1] << " iElem=" << iElem);
// face index
for (TInt f = 1; f <= aNbFaces; ++f, ++iFace ) {
int aNbFaceNodes = aPolyedre->NbFaceNodes( f );
faces[ iFace+1 ] = faces[ iFace ] + aNbFaceNodes;
//MESSAGE("faces[" << iFace+1 << "]=" << faces[iFace+1] << " iFace=" << iFace);
}
// connectivity
SMDS_ElemIteratorPtr nodeIt = anElem->nodesIterator();
while ( nodeIt->more() ) {
const SMDS_MeshElement* aNode = nodeIt->next();
#ifdef _EDF_NODE_IDS_
conn[ iNode ] = aNodeIdMap[aNode->GetID()];
//MESSAGE("conn["<< iNode << "]=" << conn[iNode] << " aNode->GetID()=" << aNode->GetID());
#else
conn[ iNode ] = aNode->GetID();
//MESSAGE("conn["<< iNode << "]=" << conn[iNode]);
#endif
++iNode;
}
// element number
aPolyhInfo->SetElemNum( iElem, anElem->GetID() );
// family number
int famNum = getFamilyId( anElemFamMap, anElem, defaultFamilyId );
aPolyhInfo->SetFamNum( iElem, famNum );
if ( ++iElem == aPolyhInfo->GetNbElem() )
break;
}
//cout << " SetPolyedreInfo(aPolyhInfo )" << endl;
myMed->SetPolyedreInfo(aPolyhInfo);
}
} // if (aElemTypeData->_geomType == ePOLYEDRE )
else
{
// Treat standard types
// ---------------------
// allocate data arrays
PCellInfo aCellInfo = myMed->CrCellInfo( aMeshInfo,
aElemTypeData->_entity,
aElemTypeData->_geomType,
aElemTypeData->_nbElems,
theConnMode,
theIsElemNum,
theIsElemNames);
// build map of family numbers for this type
if ( !isElemFamMapBuilt[ aElemTypeData->_smdsType ])
{
//cout << " fillElemFamilyMap()" << endl;
fillElemFamilyMap( anElemFamMap, aFamilies, aElemTypeData->_smdsType );
isElemFamMapBuilt[ aElemTypeData->_smdsType ] = true;
}
TInt aNbNodes = MED::GetNbNodes(aElemTypeData->_geomType);
while ( const SMDS_MeshElement* anElem = elemIterator->next() )
{
if ( anElem->NbNodes() != aNbNodes || anElem->IsPoly() )
continue; // other geometry
// connectivity
TConnSlice aTConnSlice = aCellInfo->GetConnSlice( iElem );
for (TInt iNode = 0; iNode < aNbNodes; iNode++) {
const SMDS_MeshElement* aNode = anElem->GetNode( iNode );
#ifdef _EDF_NODE_IDS_
aTConnSlice[ iNode ] = aNodeIdMap[aNode->GetID()];
#else
aTConnSlice[ iNode ] = aNode->GetID();
#endif
}
// element number
aCellInfo->SetElemNum( iElem, anElem->GetID() );
// family number
int famNum = getFamilyId( anElemFamMap, anElem, defaultFamilyId );
aCellInfo->SetFamNum( iElem, famNum );
if ( ++iElem == aCellInfo->GetNbElem() )
break;
}
// store data in a file
//cout << " SetCellInfo(aCellInfo)" << endl;
myMed->SetCellInfo(aCellInfo);
}
} // loop on geom types
}
catch(const std::exception& exc) {
INFOS("The following exception was caught:\n\t"<<exc.what());
throw;
}
catch(...) {
INFOS("Unknown exception was caught !!!");
throw;
}
myMeshId = -1;
myGroups.clear();
mySubMeshes.clear();
return aResult;
}
| void DriverMED_W_SMESHDS_Mesh::SetFile | ( | const std::string & | theFileName, |
| MED::EVersion | theId | ||
| ) |
Definition at line 57 of file DriverMED_W_SMESHDS_Mesh.cxx.
References myMed, and SetFile().
{
myMed = CrWrapper(theFileName,theId);
Driver_SMESHDS_Mesh::SetFile(theFileName);
}
| void DriverMED_W_SMESHDS_Mesh::SetFile | ( | const std::string & | theFileName | ) | [virtual] |
Reimplemented from Driver_Mesh.
Definition at line 64 of file DriverMED_W_SMESHDS_Mesh.cxx.
Referenced by SMESH_Gen_i.Save(), and SetFile().
{
return SetFile(theFileName,MED::eV2_2);
}
| void Driver_SMESHDS_Mesh::SetMesh | ( | SMESHDS_Mesh * | theMesh | ) | [inherited] |
Definition at line 31 of file Driver_SMESHDS_Mesh.cxx.
References Driver_SMESHDS_Mesh.myMesh.
Referenced by SMESH_Gen_i.Load(), and SMESH_Mesh.MEDToMesh().
{
myMesh = theMesh;
}
| void Driver_Mesh::SetMeshId | ( | int | theMeshId | ) | [inherited] |
Definition at line 37 of file Driver_Mesh.cxx.
References Driver_Mesh.myMeshId.
Referenced by SMESH_Gen_i.CreateMeshesFromMED(), SMESH_Mesh.ExportDAT(), SMESH_Mesh.ExportSTL(), SMESH_Mesh.ExportUNV(), SMESH_Gen_i.Load(), SMESH_Mesh.MEDToMesh(), SMESH_Mesh.STLToMesh(), and SMESH_Mesh.UNVToMesh().
{
myMeshId = theMeshId;
}
| void DriverMED_W_SMESHDS_Mesh::SetMeshName | ( | const std::string & | theMeshName | ) |
functions to prepare adding one mesh
Definition at line 87 of file DriverMED_W_SMESHDS_Mesh.cxx.
References myMeshName.
{
myMeshName = theMeshName;
}
Field Documentation
bool DriverMED_W_SMESHDS_Mesh.myAllSubMeshes [private] |
Definition at line 76 of file DriverMED_W_SMESHDS_Mesh.h.
Referenced by AddAllSubMeshes(), and Perform().
Definition at line 79 of file DriverMED_W_SMESHDS_Mesh.h.
Referenced by AddGroupOfEdges(), and Perform().
Definition at line 80 of file DriverMED_W_SMESHDS_Mesh.h.
Referenced by AddGroupOfFaces(), and Perform().
Definition at line 78 of file DriverMED_W_SMESHDS_Mesh.h.
Referenced by AddGroupOfNodes(), and Perform().
Definition at line 81 of file DriverMED_W_SMESHDS_Mesh.h.
Referenced by AddGroupOfVolumes(), and Perform().
std::string Driver_Mesh.myFile [protected, inherited] |
Definition at line 62 of file Driver_Mesh.h.
Referenced by DriverSTL_R_SMDS_Mesh.Perform(), Perform(), DriverSTL_R_SMDS_Mesh.readAscii(), DriverSTL_R_SMDS_Mesh.readBinary(), Driver_Mesh.SetFile(), DriverSTL_W_SMDS_Mesh.writeAscii(), and DriverSTL_W_SMDS_Mesh.writeBinary().
std::list<SMESHDS_GroupBase*> DriverMED_W_SMESHDS_Mesh.myGroups [private] |
Definition at line 75 of file DriverMED_W_SMESHDS_Mesh.h.
Referenced by AddGroup(), and Perform().
MED::PWrapper DriverMED_W_SMESHDS_Mesh.myMed [private] |
Definition at line 73 of file DriverMED_W_SMESHDS_Mesh.h.
SMESHDS_Mesh* Driver_SMESHDS_Mesh.myMesh [protected, inherited] |
Definition at line 37 of file Driver_SMESHDS_Mesh.h.
Referenced by Perform(), and Driver_SMESHDS_Mesh.SetMesh().
int Driver_Mesh.myMeshId [protected, inherited] |
Definition at line 63 of file Driver_Mesh.h.
Referenced by Perform(), and Driver_Mesh.SetMeshId().
std::string DriverMED_W_SMESHDS_Mesh.myMeshName [private] |
Definition at line 74 of file DriverMED_W_SMESHDS_Mesh.h.
Referenced by Perform(), and SetMeshName().
std::map<int,SMESHDS_SubMesh*> DriverMED_W_SMESHDS_Mesh.mySubMeshes [private] |
Definition at line 77 of file DriverMED_W_SMESHDS_Mesh.h.
Referenced by AddSubMesh(), and Perform().