- /****************************************************************************
- * ECRITURE DES NOEUDS *
- ****************************************************************************/
- MESSAGE("(************************)");
- MESSAGE("(* NOEUDS DU MAILLAGE : *)");
- MESSAGE("(************************)");
-
- /* Allocations memoires */
- /* table des coordonnees
- * profil : (dimension * nombre de noeuds ) */
- coo = (med_float *) malloc(sizeof(med_float) * nnoe * mdim);
- /* table des numeros, des numeros de familles des noeuds
- * profil : (nombre de noeuds) */
- numnoe = (med_int *) malloc(sizeof(med_int) * nnoe);
- nufano = (med_int *) malloc(sizeof(med_int) * nnoe);
- /* table des noms des noeuds
- * profil : (nnoe*MED_TAILLE_PNOM+1) */
- nomnoe = "";
-
- /* PN pour aster, il faut une famille 0 pour les noeuds et une autre pour les elements */
- /* PN : Creation de la famille 0 */
- char *nomfam = "FAMILLE_0";
- char *attdes = "";
- char *gro = 0;
- med_int ngro = 0;
- med_int natt = 1;
- med_int attide = 0;
- med_int attval = 0;
- med_int numfam = 0;
- med_int attvalabs = 1;
- ret =
- MEDfamCr(myFileId, nommaa, nomfam, numfam, &attide, &attval, attdes,
- natt, gro, ngro);
- ASSERT(ret == 0);
-
- /* PN : FIN Creation de la famille 0 */
-
- map < int, int >mapNoeud;
- typedef pair < set < int >::iterator, bool > IsFamily;
- int nbFamillesNoeud;
-
- i = 0;
- set < int >FamilySet;
- nbFamillesNoeud = 0;
- int verifienbnoeuds = 0;
- med_int *rien = 0;
-
- SMDS_Iterator<const SMDS_MeshNode *> * itNodes=myMesh->nodesIterator();
- while(itNodes->more())
- {
- const SMDS_MeshNode * node = itNodes->next();
-
- if (mdim == 3)
- {
- coo[i * 3] = node->X();
- coo[i * 3 + 1] = node->Y();
- coo[i * 3 + 2] = node->Z();
- }
- else if (mdim == 2)
- {
- if (dimX)
- {
- coo[i * 2] = node->Y();
- coo[i * 2 + 1] = node->Z();
- }
- if (dimY)
- {
- coo[i * 2] = node->X();
- coo[i * 2 + 1] = node->Z();
- }
- if (dimZ)
- {
- coo[i * 2] = node->X();
- coo[i * 2 + 1] = node->Y();
- }
- }
- else
- {
- if (dimX)
- {
- coo[i * 2] = node->Y();
- coo[i * 2 + 1] = node->Z();
- }
- if (dimY)
- {
- coo[i * 2] = node->X();
- coo[i * 2 + 1] = node->Z();
- }
- if (dimZ)
- {
- coo[i * 2] = node->X();
- coo[i * 2 + 1] = node->Y();
- }
- }
- mapNoeud[node->GetID()] = i + 1;
-
- // renvoie 0 pour les noeuds internes du volume
- int numfamille = node->GetPosition()->GetShapeId();
- nufano[i] = numfamille;
-
- //SCRUTE(i);
- //SCRUTE(nufano[i]);
- //SCRUTE(coo[i*3]);
- //SCRUTE(coo[i*3+1]);
- //SCRUTE(coo[i*3+2]);
- if (nufano[i] != 0)
- {
- IsFamily deja = FamilySet.insert(nufano[i]); // insert if new, or gives existant
- if (deja.second) // actually inserted
- {
- char famille[MED_TAILLE_NOM + 1];
- sprintf(famille, "F%d", nufano[i]);
- // CreateFamily(strdup(nommaa),strdup(famille),nufano[i],attvalabs++);
- attvalabs++;
- CreateFamily(strdup(nommaa), strdup(famille), nufano[i],
- numfamille);
- //MESSAGE("---famille-noeud--- "<<nbFamillesNoeud<<" "<<nufano[i]);
- nbFamillesNoeud++;
- }
- }
-
- i++;
- verifienbnoeuds++;
+ 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;
+ aMeshDimension = anIsXDimension + anIsYDimension + anIsZDimension;
+ if(!aMeshDimension)
+ aMeshDimension = 3;
+ // PAL16857(SMESH not conform to the MED convention):
+ if ( aMeshDimension == 2 && anIsZDimension ) // 2D only if mesh is in XOY plane
+ aMeshDimension = 3;
+ }
+
+ SMDS_NodeIteratorPtr aNodesIter = myMesh->nodesIterator();
+ switch(aMeshDimension){
+ 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;
+ }
+ }
+
+
+ PMeshInfo aMeshInfo = myMed->CrMeshInfo(aMeshDimension,aMeshName);
+ MESSAGE("Add - aMeshName : "<<aMeshName<<"; "<<aMeshInfo->GetName());
+ myMed->SetMeshInfo(aMeshInfo);
+
+ // Storing SMDS groups and sub-meshes
+ //-----------------------------------
+ int myNodesDefaultFamilyId = 0;
+ int myEdgesDefaultFamilyId = 0;
+ int myFacesDefaultFamilyId = 0;
+ int myVolumesDefaultFamilyId = 0;
+ int nbNodes = myMesh->NbNodes();
+ 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");
+ map<const SMDS_MeshElement *, int> anElemFamMap;
+ 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);
+ }
+ list<DriverMED_FamilyPtr>::iterator aFamsIter = aFamilies.begin();
+
+ for (; aFamsIter != aFamilies.end(); aFamsIter++)
+ {
+ PFamilyInfo aFamilyInfo = (*aFamsIter)->GetFamilyInfo(myMed,aMeshInfo);
+ myMed->SetFamilyInfo(aFamilyInfo);
+ int aFamId = (*aFamsIter)->GetId();
+
+ const set<const SMDS_MeshElement *>& anElems = (*aFamsIter)->GetElements();
+ set<const SMDS_MeshElement *>::const_iterator anElemsIter = anElems.begin();
+ for (; anElemsIter != anElems.end(); anElemsIter++)
+ {
+ anElemFamMap[*anElemsIter] = aFamId;
+ }
+ }
+
+ // Storing SMDS nodes to the MED file for the MED mesh
+ //----------------------------------------------------
+#ifdef _EDF_NODE_IDS_
+ typedef map<TInt,TInt> TNodeIdMap;
+ TNodeIdMap aNodeIdMap;
+#endif
+ TInt aNbElems = myMesh->NbNodes();
+ MED::TIntVector anElemNums(aNbElems);
+ MED::TIntVector aFamilyNums(aNbElems);
+ MED::TFloatVector aCoordinates(aNbElems*aMeshDimension);
+ for(TInt iNode = 0, aStartId = 0; aCoordHelperPtr->Next(); iNode++, aStartId += aMeshDimension){
+ for(TInt iCoord = 0; iCoord < aMeshDimension; iCoord++){
+ aCoordinates[aStartId+iCoord] = aCoordHelperPtr->GetCoord(iCoord);
+ }
+ int aNodeID = aCoordHelperPtr->GetID();
+ anElemNums[iNode] = aNodeID;
+#ifdef _EDF_NODE_IDS_
+ aNodeIdMap[aNodeID] = iNode+1;
+#endif
+ const SMDS_MeshNode* aNode = aCoordHelperPtr->GetNode();
+ if (anElemFamMap.find(aNode) != anElemFamMap.end())
+ aFamilyNums[iNode] = anElemFamMap[aNode];
+ else
+ aFamilyNums[iNode] = myNodesDefaultFamilyId;
+ }
+
+ MED::TStringVector aCoordNames(aMeshDimension);
+ MED::TStringVector aCoordUnits(aMeshDimension);
+ for(TInt iCoord = 0; iCoord < aMeshDimension; iCoord++){
+ aCoordNames[iCoord] = aCoordHelperPtr->GetName(iCoord);
+ aCoordUnits[iCoord] = aCoordHelperPtr->GetUnit(iCoord);
+ }
+
+ const ERepere SMDS_COORDINATE_SYSTEM = eCART;
+
+ PNodeInfo aNodeInfo = myMed->CrNodeInfo(aMeshInfo,
+ aCoordinates,
+ eFULL_INTERLACE,
+ SMDS_COORDINATE_SYSTEM,
+ aCoordNames,
+ aCoordUnits,
+ aFamilyNums,
+ anElemNums);
+ MESSAGE("Perform - aNodeInfo->GetNbElem() = "<<aNbElems);
+ myMed->SetNodeInfo(aNodeInfo);
+
+
+ // Storing others SMDS elements to the MED file for the MED mesh
+ //--------------------------------------------------------------
+ EEntiteMaillage SMDS_MED_ENTITY = eMAILLE;
+ const EConnectivite SMDS_MED_CONNECTIVITY = eNOD;
+
+ // Storing SMDS Edges
+ if(TInt aNbElems = myMesh->NbEdges()){
+#ifdef _ELEMENTS_BY_DIM_
+ SMDS_MED_ENTITY = eARETE;
+#endif
+ // count edges of diff types
+ int aNbSeg3 = 0, aNbSeg2 = 0;
+ SMDS_EdgeIteratorPtr anIter = myMesh->edgesIterator();
+ while ( anIter->more() )
+ if ( anIter->next()->NbNodes() == 3 )
+ ++aNbSeg3;
+ aNbSeg2 = aNbElems - aNbSeg3;
+
+ TInt aNbSeg2Conn = MED::GetNbNodes(eSEG2);
+ MED::TIntVector aSeg2ElemNums, aSeg2FamilyNums, aSeg2Conn;
+ aSeg2ElemNums .reserve( aNbSeg2 );
+ aSeg2FamilyNums.reserve( aNbSeg2 );
+ aSeg2Conn .reserve( aNbSeg2*aNbSeg2Conn );
+
+ TInt aNbSeg3Conn = MED::GetNbNodes(eSEG3);
+ MED::TIntVector aSeg3ElemNums, aSeg3FamilyNums, aSeg3Conn;
+ aSeg3ElemNums .reserve( aNbSeg3 );
+ aSeg3FamilyNums.reserve( aNbSeg3 );
+ aSeg3Conn .reserve( aNbSeg3*aNbSeg3Conn );
+
+ anIter = myMesh->edgesIterator();
+ while ( anIter->more() ) {
+ const SMDS_MeshEdge* anElem = anIter->next();
+ TInt aNbNodes = anElem->NbNodes();
+
+ TInt aNbConnectivity;
+ MED::TIntVector* anElemNums;
+ MED::TIntVector* aFamilyNums;
+ MED::TIntVector* aConnectivity;
+ switch(aNbNodes){
+ case 2:
+ aNbConnectivity = aNbSeg2Conn;
+ anElemNums = &aSeg2ElemNums;
+ aFamilyNums = &aSeg2FamilyNums;
+ aConnectivity = &aSeg2Conn;
+ break;
+ case 3:
+ aNbConnectivity = aNbSeg3Conn;
+ anElemNums = &aSeg3ElemNums;
+ aFamilyNums = &aSeg3FamilyNums;
+ aConnectivity = &aSeg3Conn;
+ break;
+ default:
+ break;
+ }
+
+ for(TInt iNode = 0; iNode < aNbNodes; iNode++) {
+ const SMDS_MeshElement* aNode = anElem->GetNode( iNode );
+#ifdef _EDF_NODE_IDS_
+ aConnectivity->push_back( aNodeIdMap[aNode->GetID()] );
+#else
+ aConnectivity->push_back( aNode->GetID() );
+#endif
+ }
+
+ anElemNums->push_back(anElem->GetID());
+
+ map<const SMDS_MeshElement*,int>::iterator edge_fam = anElemFamMap.find( anElem );
+ if ( edge_fam != anElemFamMap.end() )
+ aFamilyNums->push_back( edge_fam->second );
+ else
+ aFamilyNums->push_back( myEdgesDefaultFamilyId );
+ }
+
+ if ( aNbSeg2 ) {
+ PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
+ SMDS_MED_ENTITY,
+ eSEG2,
+ aSeg2Conn,
+ SMDS_MED_CONNECTIVITY,
+ aSeg2FamilyNums,
+ aSeg2ElemNums);
+ myMed->SetCellInfo(aCellInfo);
+ }
+ if ( aNbSeg3 ) {
+ PCellInfo aCellInfo = myMed->CrCellInfo(aMeshInfo,
+ SMDS_MED_ENTITY,
+ eSEG3,
+ aSeg3Conn,
+ SMDS_MED_CONNECTIVITY,
+ aSeg3FamilyNums,
+ aSeg3ElemNums);
+ myMed->SetCellInfo(aCellInfo);
+ }
+ }
+
+ // Storing SMDS Faces
+ if(TInt aNbElems = myMesh->NbFaces()){
+ SMDS_FaceIteratorPtr anIter = myMesh->facesIterator();
+#ifdef _ELEMENTS_BY_DIM_
+ SMDS_MED_ENTITY = eFACE;
+#endif
+ TInt aNbTriaConn = MED::GetNbNodes(eTRIA3);
+ MED::TIntVector anTriaElemNums;
+ anTriaElemNums.reserve(aNbElems);
+ MED::TIntVector aTriaFamilyNums;
+ aTriaFamilyNums.reserve(aNbElems);
+ MED::TIntVector aTriaConn;
+ aTriaConn.reserve(aNbElems*aNbTriaConn);
+
+ TInt aNbTria6Conn = MED::GetNbNodes(eTRIA6);
+ MED::TIntVector anTria6ElemNums;
+ anTria6ElemNums.reserve(aNbElems);
+ MED::TIntVector aTria6FamilyNums;
+ aTria6FamilyNums.reserve(aNbElems);
+ MED::TIntVector aTria6Conn;
+ aTria6Conn.reserve(aNbElems*aNbTria6Conn);
+
+ TInt aNbQuadConn = MED::GetNbNodes(eQUAD4);
+ MED::TIntVector aQuadElemNums;
+ aQuadElemNums.reserve(aNbElems);
+ MED::TIntVector aQuadFamilyNums;
+ aQuadFamilyNums.reserve(aNbElems);
+ MED::TIntVector aQuadConn;
+ aQuadConn.reserve(aNbElems*aNbQuadConn);
+
+ TInt aNbQuad8Conn = MED::GetNbNodes(eQUAD8);
+ MED::TIntVector aQuad8ElemNums;
+ aQuad8ElemNums.reserve(aNbElems);
+ MED::TIntVector aQuad8FamilyNums;
+ aQuad8FamilyNums.reserve(aNbElems);
+ MED::TIntVector aQuad8Conn;
+ aQuad8Conn.reserve(aNbElems*aNbQuad8Conn);
+
+ MED::TIntVector aPolygoneElemNums;
+ aPolygoneElemNums.reserve(aNbElems);
+ MED::TIntVector aPolygoneInds;
+ aPolygoneInds.reserve(aNbElems + 1);
+ aPolygoneInds.push_back(1); // reference on the first element in the connectivities
+ MED::TIntVector aPolygoneFamilyNums;
+ aPolygoneFamilyNums.reserve(aNbElems);
+ MED::TIntVector aPolygoneConn;
+ aPolygoneConn.reserve(aNbElems*aNbQuadConn);
+
+ for(TInt iElem = 0; iElem < aNbElems && anIter->more(); iElem++){
+ const SMDS_MeshFace* anElem = anIter->next();
+ TInt aNbNodes = anElem->NbNodes();
+ SMDS_ElemIteratorPtr aNodesIter = anElem->nodesIterator();
+ TInt aNbConnectivity;
+ MED::TIntVector* anElemNums;
+ MED::TIntVector* aFamilyNums;
+ MED::TIntVector* aConnectivity;
+ if (anElem->IsPoly()) {
+ aNbConnectivity = aNbNodes;
+ anElemNums = &aPolygoneElemNums;
+ aFamilyNums = &aPolygoneFamilyNums;
+ aConnectivity = &aPolygoneConn;
+ }
+ else {
+ switch(aNbNodes){
+ case 3:
+ aNbConnectivity = aNbTriaConn;
+ anElemNums = &anTriaElemNums;
+ aFamilyNums = &aTriaFamilyNums;
+ aConnectivity = &aTriaConn;
+ break;
+ case 4:
+ aNbConnectivity = aNbQuadConn;
+ anElemNums = &aQuadElemNums;
+ aFamilyNums = &aQuadFamilyNums;
+ aConnectivity = &aQuadConn;
+ break;
+ case 6:
+ aNbConnectivity = aNbTria6Conn;
+ anElemNums = &anTria6ElemNums;
+ aFamilyNums = &aTria6FamilyNums;
+ aConnectivity = &aTria6Conn;
+ break;
+ case 8:
+ aNbConnectivity = aNbQuad8Conn;
+ anElemNums = &aQuad8ElemNums;
+ aFamilyNums = &aQuad8FamilyNums;
+ aConnectivity = &aQuad8Conn;
+ break;
+ default:
+ break;
+ }
+ }
+ MED::TIntVector aVector(aNbNodes);
+ for(TInt iNode = 0; aNodesIter->more(); iNode++){
+ const SMDS_MeshElement* aNode = aNodesIter->next();
+#ifdef _EDF_NODE_IDS_
+ aVector[iNode] = aNodeIdMap[aNode->GetID()];
+#else
+ aVector[iNode] = aNode->GetID();
+#endif