1 // Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
3 // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License, or (at your option) any later version.
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 // Lesser General Public License for more details.
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
23 #include "MED_V2_2_Wrapper.hxx"
24 #include "MED_Algorithm.hxx"
25 #include "MED_Utilities.hxx"
29 #include <med_proto.h>
32 static int MYDEBUG = 0;
34 // static int MYDEBUG = 0;
43 GetDESCLength<eV2_2>()
50 GetIDENTLength<eV2_2>()
64 GetLNOMLength<eV2_2>()
71 GetPNOMLength<eV2_2>()
78 GetVersionRelease<eV2_2>(TInt& majeur, TInt& mineur, TInt& release)
82 release=MED_RELEASE_NUM;
87 GetNbConn<eV2_2>(EGeometrieElement typmai,
88 EEntiteMaillage typent,
97 //---------------------------------------------------------------
103 TFile(const std::string& theFileName, TInt theMinor=-1):
106 myFileName(theFileName),
109 if ((myMinor < 0) || (myMinor > MED_MINOR_NUM)) myMinor = MED_MINOR_NUM;
118 Open(EModeAcces theMode, TErr* theErr = NULL)
121 const char* aFileName = myFileName.c_str();
122 myFid = MEDfileVersionOpen(aFileName,med_access_mode(theMode), MED_MAJOR_NUM, myMinor, MED_RELEASE_NUM);
125 *theErr = TErr(myFid);
127 EXCEPTION(std::runtime_error,"TFile - MEDfileVersionOpen('"<<myFileName<<"',"<<theMode<<"',"<< MED_MAJOR_NUM<<"',"<< myMinor<<"',"<< MED_RELEASE_NUM<<")");
130 const TIdt& Id() const
133 EXCEPTION(std::runtime_error,"TFile - GetFid() < 0");
146 std::string myFileName;
151 //---------------------------------------------------------------
158 TFileWrapper(const PFile& theFile, EModeAcces theMode, TErr* theErr = NULL, TInt theMinor=-1):
162 if (myMinor < 0) myMinor = MED_MINOR_NUM;
163 myFile->Open(theMode,theErr);
173 //---------------------------------------------------------------
174 TVWrapper::TVWrapper(const std::string& theFileName, TInt theMinor):
175 myFile(new TFile(theFileName, theMinor)),
179 myFile->Open( eLECTURE_ECRITURE, &aRet );
182 myFile->Open( eLECTURE, &aRet );
186 myFile->Open( eCREATION, &aRet );
191 //----------------------------------------------------------------------------
194 ::GetNbMeshes(TErr* theErr)
196 TFileWrapper aFileWrapper(myFile,eLECTURE,theErr, myMinor);
198 if(theErr && *theErr < 0)
201 return MEDnMesh(myFile->Id());
205 //----------------------------------------------------------------------------
208 ::GetMeshInfo(TInt theMeshId,
209 MED::TMeshInfo& theInfo,
212 TFileWrapper aFileWrapper(myFile,eLECTURE,theErr, myMinor);
214 if(theErr && *theErr < 0)
217 TValueHolder<TString, char> aMeshName(theInfo.myName);
218 TValueHolder<TInt, med_int> aDim(theInfo.myDim);
219 TValueHolder<TInt, med_int> aSpaceDim(theInfo.mySpaceDim);
220 TValueHolder<EMaillage, med_mesh_type> aType(theInfo.myType);
221 char dtunit[MED_SNAME_SIZE+1];
222 med_sorting_type sorttype;
225 int naxis=MEDmeshnAxis(myFile->Id(),theMeshId);
226 char *axisname=new char[naxis*MED_SNAME_SIZE+1];
227 char *axisunit=new char[naxis*MED_SNAME_SIZE+1];
228 TErr aRet = MEDmeshInfo(myFile->Id(),
244 EXCEPTION(std::runtime_error,"GetMeshInfo - MEDmeshInfo(...)");
248 //----------------------------------------------------------------------------
251 ::SetMeshInfo(const MED::TMeshInfo& theInfo,
255 TFileWrapper aFileWrapper(myFile,theMode,theErr, myMinor);
257 if(theErr && *theErr < 0)
260 MED::TMeshInfo& anInfo = const_cast<MED::TMeshInfo&>(theInfo);
262 TValueHolder<TString, char> aMeshName(anInfo.myName);
263 TValueHolder<TInt, med_int> aDim(anInfo.myDim);
264 TValueHolder<TInt, med_int> aSpaceDim(anInfo.mySpaceDim);
265 TValueHolder<EMaillage, med_mesh_type> aType(anInfo.myType);
266 TValueHolder<TString, char> aDesc(anInfo.myDesc);
268 char *nam=new char[aSpaceDim*MED_SNAME_SIZE+1];
269 std::fill(nam,nam+aSpaceDim*MED_SNAME_SIZE+1,'\0');
270 char *unit=new char[aSpaceDim*MED_SNAME_SIZE+1];
271 std::fill(unit,unit+aSpaceDim*MED_SNAME_SIZE+1,'\0');
272 TErr aRet = MEDmeshCr(myFile->Id(),
287 // aRet = MEDunvCr(myFile->Id(),&aMeshName);
289 INITMSG(MYDEBUG,"TVWrapper::SetMeshInfo - MED_MODE_ACCES = "<<theMode<<"; aRet = "<<aRet<<std::endl);
294 EXCEPTION(std::runtime_error,"SetMeshInfo - MEDmeshCr(...)");
298 //----------------------------------------------------------------------------
301 ::SetMeshInfo(const MED::TMeshInfo& theInfo,
305 SetMeshInfo(theInfo,eLECTURE_ECRITURE,&aRet);
308 SetMeshInfo(theInfo,eLECTURE_AJOUT,&aRet);
311 SetMeshInfo(theInfo,eCREATION,&aRet);
318 //----------------------------------------------------------------------------
321 ::GetNbFamilies(const MED::TMeshInfo& theInfo,
324 TFileWrapper aFileWrapper(myFile,eLECTURE,theErr, myMinor);
326 if(theErr && *theErr < 0)
329 MED::TMeshInfo& anInfo = const_cast<MED::TMeshInfo&>(theInfo);
330 TValueHolder<TString, char> aName(anInfo.myName);
331 return MEDnFamily(myFile->Id(),&aName);
335 //----------------------------------------------------------------------------
338 ::GetNbFamAttr(TInt theFamId,
339 const MED::TMeshInfo& theInfo,
342 TFileWrapper aFileWrapper(myFile,eLECTURE,theErr, myMinor);
344 if(theErr && *theErr < 0)
347 MED::TMeshInfo& anInfo = const_cast<MED::TMeshInfo&>(theInfo);
349 TValueHolder<TString, char> aName(anInfo.myName);
351 return MEDnFamily23Attribute(myFile->Id(),&aName,theFamId);
355 //----------------------------------------------------------------------------
358 ::GetNbFamGroup(TInt theFamId,
359 const MED::TMeshInfo& theInfo,
362 TFileWrapper aFileWrapper(myFile,eLECTURE,theErr, myMinor);
364 if(theErr && *theErr < 0)
367 MED::TMeshInfo& anInfo = const_cast<MED::TMeshInfo&>(theInfo);
369 TValueHolder<TString, char> aName(anInfo.myName);
371 return MEDnFamilyGroup(myFile->Id(),&aName,theFamId);
375 //----------------------------------------------------------------------------
378 ::GetFamilyInfo(TInt theFamId,
379 MED::TFamilyInfo& theInfo,
382 TFileWrapper aFileWrapper(myFile,eLECTURE,theErr, myMinor);
384 if(theErr && *theErr < 0)
387 MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo;
389 TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
390 TValueHolder<TString, char> aFamilyName(theInfo.myName);
391 TValueHolder<TInt, med_int> aFamilyId(theInfo.myId);
392 TValueHolder<TFamAttr, med_int> anAttrId(theInfo.myAttrId);
393 TValueHolder<TFamAttr, med_int> anAttrVal(theInfo.myAttrVal);
394 TValueHolder<TString, char> anAttrDesc(theInfo.myAttrDesc);
395 TValueHolder<TString, char> aGroupNames(theInfo.myGroupNames);
397 TErr aRet = MEDfamily23Info(myFile->Id(),
410 EXCEPTION(std::runtime_error,"GetFamilyInfo - MEDfamily23Info(...) - "<<
411 " aMeshInfo.myName = '"<<&aMeshName<<
412 "'; theFamId = "<<theFamId<<
413 "; theInfo.myNbGroup = "<<theInfo.myNbGroup<<
414 "; theInfo.myNbAttr = "<<theInfo.myNbAttr);
418 //----------------------------------------------------------------------------
421 ::SetFamilyInfo(const MED::TFamilyInfo& theInfo,
425 TFileWrapper aFileWrapper(myFile,theMode,theErr, myMinor);
427 if(theErr && *theErr < 0)
430 MED::TFamilyInfo& anInfo = const_cast<MED::TFamilyInfo&>(theInfo);
431 MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo;
433 TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
434 TValueHolder<TString, char> aFamilyName(anInfo.myName);
435 TValueHolder<TInt, med_int> aFamilyId(anInfo.myId);
436 TValueHolder<TFamAttr, med_int> anAttrId(anInfo.myAttrId);
437 TValueHolder<TFamAttr, med_int> anAttrVal(anInfo.myAttrVal);
438 TValueHolder<TInt, med_int> aNbAttr(anInfo.myNbAttr);
439 TValueHolder<TString, char> anAttrDesc(anInfo.myAttrDesc);
440 TValueHolder<TInt, med_int> aNbGroup(anInfo.myNbGroup);
441 TValueHolder<TString, char> aGroupNames(anInfo.myGroupNames);
443 TErr aRet = MEDfamilyCr(myFile->Id(),
450 INITMSG(MYDEBUG,"TVWrapper::SetFamilyInfo - MED_MODE_ACCES = "<<theMode<<"; aRet = "<<aRet<<std::endl);
455 EXCEPTION(std::runtime_error,"SetFamilyInfo - MEDfamilyCr(...)");
459 //----------------------------------------------------------------------------
462 ::SetFamilyInfo(const MED::TFamilyInfo& theInfo,
466 SetFamilyInfo(theInfo,eLECTURE_ECRITURE,&aRet);
469 SetFamilyInfo(theInfo,eLECTURE_AJOUT,&aRet);
475 //----------------------------------------------------------------------------
478 ::GetNames(TElemInfo& theInfo,
480 EEntiteMaillage theEntity,
481 EGeometrieElement theGeom,
484 TFileWrapper aFileWrapper(myFile,eLECTURE,theErr, myMinor);
486 if(theErr && *theErr < 0)
489 if ( theGeom == eBALL )
490 theGeom = GetBallGeom( theInfo.myMeshInfo );
492 MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo;
494 TValueHolder<TString, char> aMeshName (aMeshInfo.myName);
495 TValueHolder<TString, char> anElemNames(theInfo.myElemNames);
496 TValueHolder<EEntiteMaillage, med_entity_type> anEntity (theEntity);
497 TValueHolder<EGeometrieElement, med_geometry_type> aGeom (theGeom);
499 TErr aRet = MEDmeshEntityNameRd(myFile->Id(),
507 theInfo.myIsElemNames = aRet != 0? eFAUX : eVRAI ;
513 //----------------------------------------------------------------------------
516 ::GetNumeration(TElemInfo& theInfo,
518 EEntiteMaillage theEntity,
519 EGeometrieElement theGeom,
522 TFileWrapper aFileWrapper(myFile,eLECTURE,theErr, myMinor);
524 if(theErr && *theErr < 0)
527 if ( theGeom == eBALL )
528 theGeom = GetBallGeom( theInfo.myMeshInfo );
530 MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo;
532 TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
533 TValueHolder<TElemNum, med_int> anElemNum(theInfo.myElemNum);
534 TValueHolder<EEntiteMaillage, med_entity_type> anEntity (theEntity);
535 TValueHolder<EGeometrieElement, med_geometry_type> aGeom (theGeom);
537 TErr aRet = MEDmeshEntityNumberRd(myFile->Id(),
545 theInfo.myIsElemNum = aRet != 0? eFAUX : eVRAI;
551 //----------------------------------------------------------------------------
554 ::GetFamilies(TElemInfo& theInfo,
556 EEntiteMaillage theEntity,
557 EGeometrieElement theGeom,
560 TFileWrapper aFileWrapper(myFile,eLECTURE,theErr, myMinor);
562 if(theErr && *theErr < 0)
565 if ( theGeom == eBALL )
566 theGeom = GetBallGeom( theInfo.myMeshInfo );
568 MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo;
570 TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
571 TValueHolder<TElemNum, med_int> aFamNum (theInfo.myFamNum);
572 TValueHolder<EEntiteMaillage, med_entity_type> anEntity (theEntity);
573 TValueHolder<EGeometrieElement, med_geometry_type> aGeom (theGeom);
575 TErr aRet = MEDmeshEntityFamilyNumberRd(myFile->Id(),
585 // if (aRet == MED_ERR_DOESNTEXIST) // --- only valid with MED3.x files
587 int aSize = (int)theInfo.myFamNum->size();
588 theInfo.myFamNum->clear();
589 theInfo.myFamNum->resize(aSize,0);
593 // EXCEPTION(std::runtime_error,"GetGrilleInfo - MEDmeshEntityFamilyNumberRd(...) of CELLS");
600 //----------------------------------------------------------------------------
603 ::SetNames(const TElemInfo& theInfo,
604 EEntiteMaillage theEntity,
605 EGeometrieElement theGeom,
608 SetNames(theInfo,eLECTURE_ECRITURE,theEntity,theGeom,theErr);
612 //----------------------------------------------------------------------------
615 ::SetNames(const TElemInfo& theInfo,
617 EEntiteMaillage theEntity,
618 EGeometrieElement theGeom,
621 TFileWrapper aFileWrapper(myFile,theMode,theErr, myMinor);
623 if(theErr && *theErr < 0)
626 if ( theGeom == eBALL )
627 theGeom = GetBallGeom( theInfo.myMeshInfo );
629 MED::TElemInfo& anInfo = const_cast<MED::TElemInfo&>(theInfo);
630 MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo;
633 if(theInfo.myIsElemNames)
635 TValueHolder<TString, char> aMeshName (aMeshInfo.myName);
636 TValueHolder<TString, char> anElemNames(anInfo.myElemNames);
637 TValueHolder<EEntiteMaillage, med_entity_type> anEntity (theEntity);
638 TValueHolder<EGeometrieElement, med_geometry_type> aGeom (theGeom);
640 aRet = MEDmeshEntityNameWr(myFile->Id(),
646 (TInt)anInfo.myElemNames->size(),
651 EXCEPTION(std::runtime_error,"SetNames - MEDmeshEntityNameWr(...)");
656 //----------------------------------------------------------------------------
659 ::SetNumeration(const TElemInfo& theInfo,
660 EEntiteMaillage theEntity,
661 EGeometrieElement theGeom,
664 SetNumeration(theInfo,eLECTURE_ECRITURE,theEntity,theGeom,theErr);
668 //----------------------------------------------------------------------------
671 ::SetNumeration(const TElemInfo& theInfo,
673 EEntiteMaillage theEntity,
674 EGeometrieElement theGeom,
677 TFileWrapper aFileWrapper(myFile,theMode,theErr, myMinor);
679 if(theErr && *theErr < 0)
682 if ( theGeom == eBALL )
683 theGeom = GetBallGeom( theInfo.myMeshInfo );
685 MED::TElemInfo& anInfo = const_cast<MED::TElemInfo&>(theInfo);
686 MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo;
689 if(theInfo.myIsElemNum)
691 TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
692 TValueHolder<TElemNum, med_int> anElemNum(anInfo.myElemNum);
693 TValueHolder<EEntiteMaillage, med_entity_type> anEntity (theEntity);
694 TValueHolder<EGeometrieElement, med_geometry_type> aGeom (theGeom);
696 aRet = MEDmeshEntityNumberWr(myFile->Id(),
702 (TInt)anInfo.myElemNum->size(),
707 EXCEPTION(std::runtime_error,"SetNumeration - MEDmeshEntityNumberWr(...)");
711 //----------------------------------------------------------------------------
714 ::SetFamilies(const TElemInfo& theInfo,
715 EEntiteMaillage theEntity,
716 EGeometrieElement theGeom,
719 SetFamilies(theInfo,eLECTURE_ECRITURE,theEntity,theGeom,theErr);
722 //----------------------------------------------------------------------------
725 ::SetFamilies(const TElemInfo& theInfo,
727 EEntiteMaillage theEntity,
728 EGeometrieElement theGeom,
731 TFileWrapper aFileWrapper(myFile,theMode,theErr, myMinor);
733 if(theErr && *theErr < 0)
736 if ( theGeom == eBALL )
737 theGeom = GetBallGeom( theInfo.myMeshInfo );
739 MED::TElemInfo& anInfo = const_cast<MED::TElemInfo&>(theInfo);
740 MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo;
742 TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
743 TValueHolder<TElemNum, med_int> aFamNum (anInfo.myFamNum);
744 TValueHolder<EEntiteMaillage, med_entity_type> anEntity (theEntity);
745 TValueHolder<EGeometrieElement, med_geometry_type> aGeom (theGeom);
747 TErr aRet = MEDmeshEntityFamilyNumberWr(myFile->Id(),
753 (TInt)anInfo.myFamNum->size(),
759 EXCEPTION(std::runtime_error,"SetFamilies - MEDmeshEntityFamilyNumberWr(...)");
762 //----------------------------------------------------------------------------
765 ::GetNbNodes(const MED::TMeshInfo& theMeshInfo,
769 TFileWrapper aFileWrapper(myFile,eLECTURE,theErr, myMinor);
771 if(theErr && *theErr < 0)
774 MED::TMeshInfo& aMeshInfo = const_cast<MED::TMeshInfo&>(theMeshInfo);
776 TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
777 TValueHolder<ETable, med_data_type > aTable(theTable);
779 return MEDmeshnEntity(myFile->Id(),
792 //----------------------------------------------------------------------------
795 ::GetNodeInfo(MED::TNodeInfo& theInfo,
798 TFileWrapper aFileWrapper(myFile,eLECTURE,theErr, myMinor);
800 if(theErr && *theErr < 0)
803 MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo;
805 TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
806 TValueHolder<TInt, med_int> aDim(aMeshInfo.myDim);
807 TValueHolder<TNodeCoord, med_float> aCoord(theInfo.myCoord);
808 TValueHolder<EModeSwitch, med_switch_mode> aModeSwitch(theInfo.myModeSwitch);
809 TValueHolder<ERepere, med_axis_type> aSystem(theInfo.mySystem);
810 TValueHolder<TString, char> aCoordNames(theInfo.myCoordNames);
811 TValueHolder<TString, char> aCoordUnits(theInfo.myCoordUnits);
812 TValueHolder<TString, char> anElemNames(theInfo.myElemNames);
813 //TValueHolder<EBooleen, med_bool> anIsElemNames(theInfo.myIsElemNames);
814 TValueHolder<TElemNum, med_int> anElemNum(theInfo.myElemNum);
815 //TValueHolder<EBooleen, med_bool> anIsElemNum(theInfo.myIsElemNum);
816 TValueHolder<TElemNum, med_int> aFamNum(theInfo.myFamNum);
817 TValueHolder<TInt, med_int> aNbElem(theInfo.myNbElem);
819 TErr aRet = MEDmeshNodeCoordinateRd(myFile->Id(),
826 TErr aRet2 =MEDmeshEntityFamilyNumberRd(myFile->Id(),
835 // if (aRet2 == MED_ERR_DOESNTEXIST) // --- only valid with MED3.x files
837 int mySize = (int)theInfo.myFamNum->size();
838 theInfo.myFamNum->clear();
839 theInfo.myFamNum->resize(mySize,0);
842 // EXCEPTION(std::runtime_error,"GetNodeInfo - MEDmeshEntityFamilyNumberRd(...)");
845 if ( MEDmeshEntityNameRd(myFile->Id(),
851 &anElemNames) < 0) theInfo.myIsElemNames=eFAUX;
853 if ( MEDmeshEntityNumberRd(myFile->Id(),
859 &anElemNum) < 0 ) theInfo.myIsElemNum=eFAUX;
864 EXCEPTION(std::runtime_error,"GetNodeInfo - MEDmeshNodeCoordinateRd(...)");
868 //----------------------------------------------------------------------------
871 ::SetNodeInfo(const MED::TNodeInfo& theInfo,
875 TFileWrapper aFileWrapper(myFile,theMode,theErr, myMinor);
877 if(theErr && *theErr < 0)
880 MED::TNodeInfo& anInfo = const_cast<MED::TNodeInfo&>(theInfo);
881 MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo;
883 TValueHolder<TString, char> aMeshName (aMeshInfo.myName);
884 TValueHolder<TNodeCoord, med_float> aCoord (anInfo.myCoord);
885 TValueHolder<EModeSwitch, med_switch_mode> aModeSwitch (anInfo.myModeSwitch);
886 TValueHolder<ERepere, med_axis_type> aSystem (anInfo.mySystem);
887 TValueHolder<TString, char> aCoordNames (anInfo.myCoordNames);
888 TValueHolder<TString, char> aCoordUnits (anInfo.myCoordUnits);
889 TValueHolder<TString, char> anElemNames (anInfo.myElemNames);
890 TValueHolder<EBooleen, med_bool> anIsElemNames(anInfo.myIsElemNames);
891 TValueHolder<TElemNum, med_int> anElemNum (anInfo.myElemNum);
892 TValueHolder<EBooleen, med_bool> anIsElemNum (anInfo.myIsElemNum);
893 TValueHolder<TElemNum, med_int> aFamNum (anInfo.myFamNum);
894 TValueHolder<TInt, med_int> aNbElem (anInfo.myNbElem);
896 TErr aRet = MEDmeshNodeCoordinateWr(myFile->Id(),
905 MEDmeshEntityFamilyNumberWr(myFile->Id(),
914 MEDmeshEntityNameWr(myFile->Id(),
923 MEDmeshEntityNumberWr(myFile->Id(),
934 EXCEPTION(std::runtime_error,"SetNodeInfo - MEDmeshNodeCoordinateWr(...)");
938 //----------------------------------------------------------------------------
941 ::SetNodeInfo(const MED::TNodeInfo& theInfo,
945 SetNodeInfo(theInfo,eLECTURE_ECRITURE,&aRet);
948 SetNodeInfo(theInfo,eLECTURE_AJOUT,&aRet);
955 //-----------------------------------------------------------------
958 ::GetPolygoneInfo(MED::TPolygoneInfo& theInfo,
961 TFileWrapper aFileWrapper(myFile,eLECTURE,theErr, myMinor);
963 if(theErr && *theErr < 0)
966 MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo;
968 TValueHolder<TString, char > aMeshName(aMeshInfo.myName);
969 TValueHolder<TElemNum, med_int > anIndex (theInfo.myIndex);
970 TValueHolder<TElemNum, med_int > aConn (theInfo.myConn);
971 TValueHolder<EEntiteMaillage, med_entity_type > anEntity (theInfo.myEntity);
972 TValueHolder<EGeometrieElement, med_geometry_type> aGeom (theInfo.myGeom);
973 TValueHolder<EConnectivite, med_connectivity_mode> aConnMode(theInfo.myConnMode);
974 TInt aNbElem = (TInt)theInfo.myElemNum->size();
977 aRet = MEDmeshPolygon2Rd(myFile->Id(), &aMeshName,
978 MED_NO_DT, MED_NO_IT,
980 aConnMode, &anIndex, &aConn);
985 EXCEPTION(std::runtime_error,"GetPolygoneInfo - MEDmeshPolygonRd(...)");
987 if(theInfo.myIsElemNames){
988 GetNames(theInfo,aNbElem,theInfo.myEntity,theInfo.myGeom,&aRet);
993 if(theInfo.myIsElemNum){
994 GetNumeration(theInfo,aNbElem,theInfo.myEntity,theInfo.myGeom,&aRet);
999 GetFamilies(theInfo,aNbElem,theInfo.myEntity,theInfo.myGeom,&aRet);
1004 //----------------------------------------------------------------------------
1007 ::SetPolygoneInfo(const MED::TPolygoneInfo& theInfo,
1010 SetPolygoneInfo(theInfo,eLECTURE_ECRITURE,theErr);
1013 //----------------------------------------------------------------------------
1016 ::SetPolygoneInfo(const MED::TPolygoneInfo& theInfo,
1020 TFileWrapper aFileWrapper(myFile,theMode,theErr, myMinor);
1022 if(theErr && *theErr < 0)
1025 MED::TPolygoneInfo& anInfo = const_cast<MED::TPolygoneInfo&>(theInfo);
1026 MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo;
1028 TValueHolder<TString, char > aMeshName(aMeshInfo.myName);
1029 TValueHolder<TElemNum, med_int > anIndex (anInfo.myIndex);
1030 TValueHolder<TElemNum, med_int > aConn (anInfo.myConn);
1031 TValueHolder<EEntiteMaillage, med_entity_type > anEntity (anInfo.myEntity);
1032 TValueHolder<EGeometrieElement, med_geometry_type> aGeom (anInfo.myGeom);
1033 TValueHolder<EConnectivite, med_connectivity_mode> aConnMode(anInfo.myConnMode);
1035 TErr aRet = MEDmeshPolygon2Wr(myFile->Id(), &aMeshName,
1036 MED_NO_DT, MED_NO_IT, MED_UNDEF_DT,
1038 aConnMode, anInfo.myNbElem + 1,
1043 EXCEPTION(std::runtime_error,"SetPolygoneInfo - MEDmeshPolygonWr(...)");
1045 SetNames(anInfo,theInfo.myEntity,anInfo.myGeom,&aRet);
1049 SetNumeration(anInfo,theInfo.myEntity,anInfo.myGeom,&aRet);
1053 SetFamilies(anInfo,theInfo.myEntity,anInfo.myGeom,&aRet);
1058 //----------------------------------------------------------------------------
1061 ::GetNbPolygones(const MED::TMeshInfo& theMeshInfo,
1062 EEntiteMaillage theEntity,
1063 EGeometrieElement theGeom,
1064 EConnectivite theConnMode,
1067 return GetNbCells(theMeshInfo,theEntity,theGeom,theConnMode,theErr);
1070 //----------------------------------------------------------------------------
1073 ::GetPolygoneConnSize(const MED::TMeshInfo& theMeshInfo,
1074 EEntiteMaillage theEntity,
1075 EGeometrieElement theGeom,
1076 EConnectivite theConnMode,
1079 TFileWrapper aFileWrapper(myFile,eLECTURE,theErr, myMinor);
1081 if(theErr && *theErr < 0)
1084 MED::TMeshInfo& aMeshInfo = const_cast<MED::TMeshInfo&>(theMeshInfo);
1086 TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
1087 med_int aTaille = 0;
1089 aTaille=MEDmeshnEntity(myFile->Id(),
1093 med_entity_type(theEntity),
1094 med_geometry_type(theGeom),
1096 med_connectivity_mode(theConnMode),
1102 EXCEPTION(std::runtime_error,"GetPolygoneInfo - MEDmeshnEntity(...)");
1104 return TInt(aTaille);
1107 //-----------------------------------------------------------------
1110 ::GetPolyedreInfo(TPolyedreInfo& theInfo,
1113 TFileWrapper aFileWrapper(myFile,eLECTURE,theErr, myMinor);
1115 if(theErr && *theErr < 0)
1118 MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo;
1120 TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
1121 TInt aNbElem = (TInt)theInfo.myElemNum->size();
1122 TValueHolder<TElemNum, med_int> anIndex(theInfo.myIndex);
1123 TValueHolder<TElemNum, med_int> aFaces(theInfo.myFaces);
1124 TValueHolder<TElemNum, med_int> aConn(theInfo.myConn);
1125 TValueHolder<EConnectivite, med_connectivity_mode> aConnMode(theInfo.myConnMode);
1128 aRet = MEDmeshPolyhedronRd(myFile->Id(),
1141 EXCEPTION(std::runtime_error,"GetPolygoneInfo - MEDmeshPolyhedronRd(...)");
1143 if(theInfo.myIsElemNames){
1144 GetNames(theInfo,aNbElem,theInfo.myEntity,ePOLYEDRE,&aRet);
1149 if(theInfo.myIsElemNum){
1150 GetNumeration(theInfo,aNbElem,theInfo.myEntity,ePOLYEDRE,&aRet);
1155 GetFamilies(theInfo,aNbElem,theInfo.myEntity,ePOLYEDRE,&aRet);
1160 //----------------------------------------------------------------------------
1163 ::SetPolyedreInfo(const TPolyedreInfo& theInfo,
1166 SetPolyedreInfo(theInfo,eLECTURE_ECRITURE,theErr);
1169 //----------------------------------------------------------------------------
1172 ::SetPolyedreInfo(const MED::TPolyedreInfo& theInfo,
1176 TFileWrapper aFileWrapper(myFile,theMode,theErr, myMinor);
1178 if(theErr && *theErr < 0)
1181 MED::TPolyedreInfo& anInfo = const_cast<MED::TPolyedreInfo&>(theInfo);
1182 MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo;
1184 TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
1185 TValueHolder<TElemNum, med_int> anIndex(anInfo.myIndex);
1186 TValueHolder<TElemNum, med_int> aFaces(anInfo.myFaces);
1187 TValueHolder<TElemNum, med_int> aConn(anInfo.myConn);
1188 TValueHolder<EConnectivite, med_connectivity_mode> aConnMode(anInfo.myConnMode);
1191 aRet = MEDmeshPolyhedronWr(myFile->Id(),
1200 (TInt)anInfo.myFaces->size(),
1207 EXCEPTION(std::runtime_error,"SetPolyedreInfo - MEDmeshPolyhedronWr(...)");
1209 TValueHolder<EEntiteMaillage, med_entity_type> anEntity(anInfo.myEntity);
1211 if(theInfo.myIsElemNames){
1212 TValueHolder<TString, char> anElemNames(anInfo.myElemNames);
1213 aRet = MEDmeshEntityNameWr(myFile->Id(),
1219 (TInt)anInfo.myElemNames->size(),
1224 EXCEPTION(std::runtime_error,"SetPolyedreInfo - MEDmeshEntityNameWr(...)");
1227 if(theInfo.myIsElemNum){
1228 TValueHolder<TElemNum, med_int> anElemNum(anInfo.myElemNum);
1229 aRet = MEDmeshEntityNumberWr(myFile->Id(),
1235 (TInt)anInfo.myElemNum->size(),
1240 EXCEPTION(std::runtime_error,"SetPolyedreInfo - MEDmeshEntityNumberWr(...)");
1244 TValueHolder<TElemNum, med_int> aFamNum(anInfo.myFamNum);
1245 aRet = MEDmeshEntityFamilyNumberWr(myFile->Id(),
1251 (TInt)anInfo.myFamNum->size(),
1257 EXCEPTION(std::runtime_error,"SetPolyedreInfo - MEDmeshEntityFamilyNumberWr(...)");
1260 //----------------------------------------------------------------------------
1263 ::GetNbPolyedres(const MED::TMeshInfo& theMeshInfo,
1264 EEntiteMaillage theEntity,
1265 EGeometrieElement theGeom,
1266 EConnectivite theConnMode,
1269 return GetNbCells(theMeshInfo,theEntity,theGeom,theConnMode,theErr);
1272 //----------------------------------------------------------------------------
1274 TVWrapper ::GetPolyedreConnSize(const TMeshInfo& theMeshInfo,
1277 EConnectivite theConnMode,
1280 TFileWrapper aFileWrapper(myFile,eLECTURE,theErr, myMinor);
1282 if(theErr && *theErr < 0)
1283 EXCEPTION(std::runtime_error,"GetPolyedreConnSize - (...)");
1285 MED::TMeshInfo& aMeshInfo = const_cast<MED::TMeshInfo&>(theMeshInfo);
1287 TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
1288 TValueHolder<EConnectivite, med_connectivity_mode> aConnMode(theConnMode);
1289 //TValueHolder<TInt, med_int> aNbFaces(theNbFaces);
1290 //TValueHolder<TInt, med_int> aConnSize(theConnSize);
1293 theNbFaces = MEDmeshnEntity(myFile->Id(),
1304 theConnSize = MEDmeshnEntity(myFile->Id(),
1315 if(theNbFaces < 0 || theConnSize<0)
1316 EXCEPTION(std::runtime_error,"GetPolygoneInfo - MEDmeshnEntity(...)");
1320 //-----------------------------------------------------------------
1323 ::GetEntityInfo(const MED::TMeshInfo& theMeshInfo,
1324 EConnectivite theConnMode,
1329 TFileWrapper aFileWrapper(myFile,eLECTURE,theErr, myMinor);
1331 if(theErr && *theErr < 0)
1334 if(theMeshInfo.GetType() == eNON_STRUCTURE) {
1335 TInt aNbElem = GetNbNodes(theMeshInfo);
1337 anInfo[eNOEUD][ePOINT1] = aNbElem;
1338 const TEntity2GeomSet& anEntity2GeomSet = GetEntity2GeomSet();
1339 TEntity2GeomSet::const_iterator anIter = anEntity2GeomSet.begin();
1340 TEntity2GeomSet::const_iterator anIterEnd = anEntity2GeomSet.end();
1341 for(; anIter != anIterEnd; anIter++){
1342 const EEntiteMaillage& anEntity = anIter->first;
1343 const TGeomSet& aGeomSet = anIter->second;
1344 TGeomSet::const_iterator anIter2 = aGeomSet.begin();
1345 TGeomSet::const_iterator anIterEnd2 = aGeomSet.end();
1346 for(; anIter2 != anIterEnd2; anIter2++){
1347 const EGeometrieElement& aGeom = *anIter2;
1348 aNbElem = GetNbCells(theMeshInfo,anEntity,aGeom,theConnMode,theErr);
1350 if ( anEntity == eSTRUCT_ELEMENT ) {
1351 const TInt nbStructTypes = aNbElem;
1352 for ( TInt structType = 0; structType < nbStructTypes; ++structType ) {
1353 // check type name to keep only "MED_BALL" structured element
1354 TValueHolder<TString, char> aMeshName((TString&) theMeshInfo.myName );
1355 char geotypename[ MED_NAME_SIZE + 1] = "";
1356 med_geometry_type geotype;
1357 MEDmeshEntityInfo( myFile->Id(), &aMeshName, MED_NO_DT, MED_NO_IT,
1358 med_entity_type(anEntity), structType+1,
1359 geotypename, &geotype);
1360 if ( strcmp( geotypename, MED_BALL_NAME ) == 0 ) {
1361 aNbElem = GetNbCells( theMeshInfo, anEntity, EGeometrieElement(geotype),
1362 theConnMode, theErr);
1364 anInfo[anEntity][EGeometrieElement(geotype)] = aNbElem;
1369 anInfo[anEntity][aGeom] = aNbElem;
1375 } else { // eSTRUCTURE
1376 EGrilleType aGrilleType;
1380 TInt aDim = theMeshInfo.GetDim();
1381 EGeometrieElement aGeom, aSubGeom;
1382 EEntiteMaillage aSubEntity = eMAILLE;
1384 GetGrilleType(theMeshInfo, aGrilleType);
1386 TIntVector aStruct(aDim);
1387 if(aGrilleType == eGRILLE_STANDARD)
1389 GetGrilleStruct(theMeshInfo, aStruct, theErr);
1392 { // eGRILLE_CARTESIENNE and eGRILLE_POLAIRE
1393 ETable aTable[3] = { eCOOR_IND1, eCOOR_IND2, eCOOR_IND3 };
1394 for(med_int anAxis = 0; anAxis < aDim; anAxis++)
1395 aStruct[ anAxis ] = GetNbNodes(theMeshInfo, aTable[anAxis]);
1397 for(med_int i = 0; i < aDim; i++){
1398 aNbNodes = aNbNodes * aStruct[i];
1399 aNbElem = aNbElem * (aStruct[i] - 1);
1408 aSubEntity = eARETE;
1410 (aStruct[0] ) * (aStruct[1]-1) +
1411 (aStruct[0]-1) * (aStruct[1] );
1418 (aStruct[0] ) * (aStruct[1]-1) * (aStruct[2]-1) +
1419 (aStruct[0]-1) * (aStruct[1] ) * (aStruct[2]-1) +
1420 (aStruct[0]-1) * (aStruct[1]-1) * (aStruct[2] );
1423 anInfo[eNOEUD][ePOINT1] = aNbNodes;
1424 anInfo[eMAILLE][aGeom] = aNbElem;
1426 anInfo[aSubEntity][aSubGeom] = aNbSub;
1432 //-----------------------------------------------------------------
1433 TInt TVWrapper::GetNbCells(const MED::TMeshInfo& theMeshInfo,
1434 EEntiteMaillage theEntity,
1435 EGeometrieElement theGeom,
1436 EConnectivite theConnMode,
1439 TFileWrapper aFileWrapper(myFile,eLECTURE,theErr, myMinor);
1441 if(theErr && *theErr < 0)
1444 MED::TMeshInfo& aMeshInfo = const_cast<MED::TMeshInfo&>(theMeshInfo);
1445 TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
1449 case MED::ePOLYGONE:
1450 case MED::ePOLYGON2:
1452 return MEDmeshnEntity(myFile->Id(),&aMeshName,
1453 MED_NO_DT,MED_NO_IT,
1454 med_entity_type(theEntity),med_geometry_type(theGeom),
1455 MED_INDEX_NODE,med_connectivity_mode(theConnMode),
1458 case MED::ePOLYEDRE:
1460 return MEDmeshnEntity(myFile->Id(),&aMeshName,
1461 MED_NO_DT,MED_NO_IT,
1462 med_entity_type(theEntity),MED_POLYHEDRON,
1463 MED_INDEX_FACE,med_connectivity_mode(theConnMode),
1468 return GetNbBalls( theMeshInfo );
1472 return MEDmeshnEntity(myFile->Id(),&aMeshName,
1473 MED_NO_DT,MED_NO_IT,
1474 med_entity_type(theEntity),med_geometry_type(theGeom),
1475 MED_CONNECTIVITY,med_connectivity_mode(theConnMode),
1483 //----------------------------------------------------------------------------
1484 void TVWrapper::GetCellInfo(MED::TCellInfo& theInfo, TErr* theErr)
1486 TFileWrapper aFileWrapper(myFile,eLECTURE,theErr, myMinor);
1488 if(theErr && *theErr < 0)
1491 MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo;
1493 TValueHolder<TString, char> aMeshName (aMeshInfo.myName);
1494 TValueHolder<TElemNum, med_int> aConn (theInfo.myConn);
1495 TValueHolder<EModeSwitch, med_switch_mode> aModeSwitch (theInfo.myModeSwitch);
1496 TValueHolder<TString, char> anElemNames (theInfo.myElemNames);
1497 TValueHolder<EBooleen, med_bool> anIsElemNames(theInfo.myIsElemNames);
1498 TValueHolder<TElemNum, med_int> anElemNum (theInfo.myElemNum);
1499 TValueHolder<EBooleen, med_bool> anIsElemNum (theInfo.myIsElemNum);
1500 TValueHolder<TElemNum, med_int> aFamNum (theInfo.myFamNum);
1501 TValueHolder<EBooleen, med_bool> anIsFamNum (theInfo.myIsFamNum);
1502 TValueHolder<EEntiteMaillage, med_entity_type> anEntity (theInfo.myEntity);
1503 TValueHolder<EGeometrieElement, med_geometry_type> aGeom (theInfo.myGeom);
1504 TValueHolder<EConnectivite, med_connectivity_mode> aConnMode (theInfo.myConnMode);
1507 aRet = MEDmeshElementRd(myFile->Id(),
1526 EXCEPTION(std::runtime_error,"GetCellInfo - MEDmeshElementRd(...)");
1528 if (anIsFamNum == MED_FALSE)
1530 int mySize = (int) theInfo.myFamNum->size();
1531 theInfo.myFamNum->clear();
1532 theInfo.myFamNum->resize(mySize, 0);
1538 //----------------------------------------------------------------------------
1541 ::SetCellInfo(const MED::TCellInfo& theInfo,
1545 TFileWrapper aFileWrapper(myFile,theMode,theErr, myMinor);
1547 if(theErr && *theErr < 0)
1550 MED::TCellInfo& anInfo = const_cast<MED::TCellInfo&>(theInfo);
1551 MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo;
1553 TValueHolder<TString, char> aMeshName (aMeshInfo.myName);
1554 TValueHolder<TElemNum, med_int> aConn (anInfo.myConn);
1555 TValueHolder<EModeSwitch, med_switch_mode> aModeSwitch (anInfo.myModeSwitch);
1556 TValueHolder<TString, char> anElemNames (anInfo.myElemNames);
1557 TValueHolder<EBooleen, med_bool> anIsElemNames(anInfo.myIsElemNames);
1558 TValueHolder<TElemNum, med_int> anElemNum (anInfo.myElemNum);
1559 TValueHolder<EBooleen, med_bool> anIsElemNum (anInfo.myIsElemNum);
1560 TValueHolder<TElemNum, med_int> aFamNum (anInfo.myFamNum);
1561 TValueHolder<EBooleen, med_bool> anIsFamNum (anInfo.myIsFamNum);
1562 TValueHolder<EEntiteMaillage, med_entity_type> anEntity (anInfo.myEntity);
1563 TValueHolder<EGeometrieElement, med_geometry_type> aGeom (anInfo.myGeom);
1564 TValueHolder<EConnectivite, med_connectivity_mode> aConnMode (anInfo.myConnMode);
1565 TValueHolder<TInt, med_int> aNbElem (anInfo.myNbElem);
1568 aRet = MEDmeshElementConnectivityWr(myFile->Id(),
1580 MEDmeshEntityFamilyNumberWr(myFile->Id(),
1589 MEDmeshEntityNameWr(myFile->Id(),
1598 MEDmeshEntityNumberWr(myFile->Id(),
1609 EXCEPTION(std::runtime_error,"SetCellInfo - MEDmeshElementWr(...)");
1613 //----------------------------------------------------------------------------
1616 ::SetCellInfo(const MED::TCellInfo& theInfo,
1619 SetCellInfo(theInfo,eLECTURE_ECRITURE,theErr);
1622 //----------------------------------------------------------------------------
1623 //! Read geom type of MED_BALL structural element
1624 EGeometrieElement TVWrapper::GetBallGeom(const TMeshInfo& theMeshInfo)
1627 TFileWrapper aFileWrapper(myFile, eLECTURE, &anError, myMinor);
1629 // read med_geometry_type of "MED_BALL" element
1630 char geotypename[ MED_NAME_SIZE + 1] = MED_BALL_NAME;
1631 return EGeometrieElement( MEDstructElementGeotype( myFile->Id(), geotypename ) );
1634 //----------------------------------------------------------------------------
1635 //! Read number of balls in the Mesh
1636 TInt TVWrapper::GetNbBalls(const TMeshInfo& theMeshInfo)
1639 TFileWrapper aFileWrapper(myFile, eLECTURE, &anError, myMinor);
1641 EGeometrieElement ballType = GetBallGeom( theMeshInfo );
1645 return GetNbCells( theMeshInfo, eSTRUCT_ELEMENT, ballType, eNOD );
1648 //----------------------------------------------------------------------------
1649 //! Read a MEDWrapped representation of MED_BALL from the MED file
1650 void TVWrapper::GetBallInfo(TBallInfo& theInfo, TErr* theErr)
1652 TFileWrapper aFileWrapper(myFile,eLECTURE,theErr, myMinor);
1654 // check geometry of MED_BALL
1655 if ( theInfo.myGeom == eBALL )
1657 theInfo.myGeom = GetBallGeom( *theInfo.myMeshInfo );
1658 if ( theInfo.myGeom < 0 ) {
1660 EXCEPTION(std::runtime_error,"GetBallInfo - no balls in the mesh");
1661 *theErr = theInfo.myGeom;
1667 GetCellInfo( theInfo );
1670 TValueHolder<TString, char> aMeshName (theInfo.myMeshInfo->myName);
1671 TValueHolder<EGeometrieElement, med_geometry_type> aGeom (theInfo.myGeom);
1672 TValueHolder<TFloatVector, void> aDiam (theInfo.myDiameters);
1673 char varattname[ MED_NAME_SIZE + 1] = MED_BALL_DIAMETER;
1675 TErr aRet = MEDmeshStructElementVarAttRd( myFile->Id(), &aMeshName,
1676 MED_NO_DT, MED_NO_IT,
1682 else if ( aRet < 0 )
1683 EXCEPTION(std::runtime_error,"GetBallInfo - pb at reading diameters");
1687 //----------------------------------------------------------------------------
1688 //! Write a MEDWrapped representation of MED_BALL to the MED file
1689 void TVWrapper::SetBallInfo(const TBallInfo& theInfo, EModeAcces theMode, TErr* theErr)
1691 TFileWrapper aFileWrapper(myFile,theMode,theErr, myMinor);
1694 char ballsupportname[MED_NAME_SIZE+1]="BALL_SUPPORT_MESH";
1695 EGeometrieElement ballGeom = GetBallGeom( *theInfo.myMeshInfo );
1698 // no ball model in the file, create support mesh for it
1699 char dummyname [MED_NAME_SIZE*3+1]="";
1700 if (( ret = MEDsupportMeshCr( myFile->Id(),
1702 theInfo.myMeshInfo->GetSpaceDim(),
1703 theInfo.myMeshInfo->GetDim(),
1704 "Support mesh for a ball model",
1706 /*axisname=*/dummyname, /*unitname=*/dummyname)) < 0) {
1708 EXCEPTION(std::runtime_error,"SetBallInfo - MEDsupportMeshCr");
1712 // write coordinates of 1 node
1713 med_float coord[3] = {0,0,0};
1714 if ((ret = MEDmeshNodeCoordinateWr(myFile->Id(),
1715 ballsupportname, MED_NO_DT, MED_NO_IT, 0.0,
1716 MED_FULL_INTERLACE, /*nnode=*/1, coord)) < 0) {
1718 EXCEPTION(std::runtime_error,"SetBallInfo - MEDmeshNodeCoordinateWr");
1722 // ball model creation
1723 char geotypename[ MED_NAME_SIZE + 1] = MED_BALL_NAME;
1724 if (( ballGeom = (EGeometrieElement) MEDstructElementCr(myFile->Id(),
1726 theInfo.myMeshInfo->GetSpaceDim(),
1728 MED_NODE,MED_NONE)) < 0 ) {
1730 EXCEPTION(std::runtime_error,"SetBallInfo - MEDstructElementCr");
1734 // create diameter attribute
1735 if (( ret = MEDstructElementVarAttCr(myFile->Id(),
1736 geotypename, MED_BALL_DIAMETER,
1737 MED_ATT_FLOAT64, /*ncomp=*/1)) < 0) {
1739 EXCEPTION(std::runtime_error,"SetBallInfo - MEDstructElementVarAttCr");
1745 TBallInfo& aBallInfo = ((TBallInfo&) theInfo );
1746 aBallInfo.myGeom = ballGeom;
1749 SetCellInfo(theInfo,theMode,theErr);
1750 if ( theErr && theErr < 0 )
1754 TValueHolder<TString, char> aMeshName (aBallInfo.myMeshInfo->myName);
1755 TValueHolder<EGeometrieElement, med_geometry_type> aGeom (aBallInfo.myGeom);
1756 TValueHolder<TFloatVector, void> aDiam (aBallInfo.myDiameters);
1757 ret = MEDmeshStructElementVarAttWr(myFile->Id(), &aMeshName,
1758 MED_NO_DT, MED_NO_IT,
1759 aGeom, MED_BALL_DIAMETER,
1760 theInfo.myNbElem, &aDiam);
1764 EXCEPTION(std::runtime_error,"SetBallInfo - MEDmeshStructElementVarAttWr");
1767 //----------------------------------------------------------------------------
1768 //! Write a MEDWrapped representation of MED_BALL to the MED file
1769 void TVWrapper::SetBallInfo(const TBallInfo& theInfo, TErr* theErr)
1771 SetBallInfo( theInfo, eLECTURE_ECRITURE, theErr );
1774 //-----------------------------------------------------------------
1777 ::GetNbFields(TErr* theErr)
1779 TFileWrapper aFileWrapper(myFile,eLECTURE,theErr, myMinor);
1781 if(theErr && *theErr < 0)
1784 return MEDnField(myFile->Id());
1788 //----------------------------------------------------------------------------
1791 ::GetNbComp(TInt theFieldId,
1794 TFileWrapper aFileWrapper(myFile,eLECTURE,theErr, myMinor);
1796 if(theErr && *theErr < 0)
1799 return MEDfieldnComponent(myFile->Id(),theFieldId);
1803 //----------------------------------------------------------------------------
1806 ::GetFieldInfo(TInt theFieldId,
1807 MED::TFieldInfo& theInfo,
1810 TFileWrapper aFileWrapper(myFile,eLECTURE,theErr, myMinor);
1812 if(theErr && *theErr < 0)
1815 TString aFieldName(256); // Protect from memory problems with too long names
1816 TValueHolder<ETypeChamp, med_field_type> aType(theInfo.myType);
1817 TValueHolder<TString, char> aCompNames(theInfo.myCompNames);
1818 TValueHolder<TString, char> anUnitNames(theInfo.myUnitNames);
1819 MED::TMeshInfo& aMeshInfo = theInfo.myMeshInfo;
1823 char dtunit[MED_SNAME_SIZE+1];
1824 char local_mesh_name[MED_NAME_SIZE+1]="";
1826 theInfo.myNbComp = MEDfieldnComponent(myFile->Id(),theFieldId);
1827 aRet = MEDfieldInfo(myFile->Id(),
1838 if(strcmp(&aMeshInfo.myName[0],local_mesh_name) != 0 ) {
1844 theInfo.SetName(aFieldName);
1849 EXCEPTION(std::runtime_error,"GetFieldInfo - MEDfieldInfo(...)");
1853 //----------------------------------------------------------------------------
1856 ::SetFieldInfo(const MED::TFieldInfo& theInfo,
1860 TFileWrapper aFileWrapper(myFile,theMode,theErr, myMinor);
1862 if(theErr && *theErr < 0)
1865 MED::TFieldInfo& anInfo = const_cast<MED::TFieldInfo&>(theInfo);
1867 TValueHolder<TString, char> aFieldName(anInfo.myName);
1868 TValueHolder<ETypeChamp, med_field_type> aType(anInfo.myType);
1869 TValueHolder<TString, char> aCompNames(anInfo.myCompNames);
1870 TValueHolder<TString, char> anUnitNames(anInfo.myUnitNames);
1871 MED::TMeshInfo& aMeshInfo = anInfo.myMeshInfo;
1873 char dtunit[MED_SNAME_SIZE+1];
1874 std::fill(dtunit,dtunit+MED_SNAME_SIZE+1,'\0');
1875 aRet = MEDfieldCr(myFile->Id(),
1882 &aMeshInfo.myName[0]);
1886 EXCEPTION(std::runtime_error,"SetFieldInfo - MEDfieldCr(...)");
1890 //----------------------------------------------------------------------------
1893 ::SetFieldInfo(const MED::TFieldInfo& theInfo,
1897 SetFieldInfo(theInfo,eLECTURE_ECRITURE,&aRet);
1900 SetFieldInfo(theInfo,eLECTURE_AJOUT,&aRet);
1907 //----------------------------------------------------------------------------
1910 ::GetNbGauss(TErr* theErr)
1912 TFileWrapper aFileWrapper(myFile,eLECTURE,theErr, myMinor);
1914 if(theErr && *theErr < 0)
1917 return MEDnLocalization(myFile->Id());
1921 //----------------------------------------------------------------------------
1924 ::GetGaussPreInfo(TInt theId,
1927 TFileWrapper aFileWrapper(myFile,eLECTURE,theErr, myMinor);
1929 if(theErr && *theErr < 0)
1930 return TGaussInfo::TInfo( TGaussInfo::TKey(ePOINT1,""),0 );
1932 med_int aNbGaussPoints = med_int();
1933 TVector<char> aName(GetNOMLength<eV2_2>()+1);
1934 med_geometry_type aGeom = MED_NONE;
1938 char geointerpname[MED_NAME_SIZE+1]="";
1939 char ipointstructmeshname[MED_NAME_SIZE+1]="";
1940 med_int nsectionmeshcell;
1941 med_geometry_type sectiongeotype;
1942 aRet = MEDlocalizationInfo (myFile->Id(),
1949 ipointstructmeshname,
1955 EXCEPTION(std::runtime_error,"GetGaussPreInfo - MEDlocalizationInfo(...)");
1956 return TGaussInfo::TInfo(TGaussInfo::TKey(EGeometrieElement(aGeom),&aName[0]),
1957 TInt(aNbGaussPoints));
1961 //----------------------------------------------------------------------------
1964 ::GetGaussInfo(TInt theId,
1965 TGaussInfo& theInfo,
1968 TFileWrapper aFileWrapper(myFile,eLECTURE,theErr, myMinor);
1970 if(theErr && *theErr < 0)
1973 TValueHolder<TNodeCoord, med_float> aRefCoord(theInfo.myRefCoord);
1974 TValueHolder<TNodeCoord, med_float> aGaussCoord(theInfo.myGaussCoord);
1975 TValueHolder<TWeight, med_float> aWeight(theInfo.myWeight);
1976 TValueHolder<EModeSwitch, med_switch_mode> aModeSwitch(theInfo.myModeSwitch);
1977 TValueHolder<TString, char> aGaussName(theInfo.myName);
1980 aRet = MEDlocalizationRd(myFile->Id(),
1990 EXCEPTION(std::runtime_error,"GetGaussInfo - MEDlocalizationRd(...)");
1994 //----------------------------------------------------------------------------
1997 ::GetNbProfiles(TErr* theErr)
1999 TFileWrapper aFileWrapper(myFile,eLECTURE,theErr, myMinor);
2001 if(theErr && *theErr < 0)
2004 return MEDnProfile(myFile->Id());
2009 ::GetProfilePreInfo(TInt theId,
2012 TFileWrapper aFileWrapper(myFile,eLECTURE,theErr, myMinor);
2014 if(theErr && *theErr < 0)
2015 return TProfileInfo::TInfo();
2018 TVector<char> aName(GetNOMLength<eV2_2>()+1);
2021 aRet = MEDprofileInfo(myFile->Id(),
2028 EXCEPTION(std::runtime_error,"GetProfilePreInfo - MEDprofileInfo(...)");
2030 return TProfileInfo::TInfo(&aName[0],aSize);
2035 ::GetProfileInfo(TInt theId,
2036 TProfileInfo& theInfo,
2039 TFileWrapper aFileWrapper(myFile,eLECTURE,theErr, myMinor);
2041 if(theErr && *theErr < 0)
2044 TProfileInfo& anInfo = const_cast<TProfileInfo&>(theInfo);
2045 TValueHolder<TElemNum, med_int> anElemNum(anInfo.myElemNum);
2046 TValueHolder<TString, char> aProfileName(anInfo.myName);
2049 aRet = MEDprofileRd(myFile->Id(),
2055 EXCEPTION(std::runtime_error,"GetProfileInfo - MEDprofileRd(...)");
2060 ::SetProfileInfo(const TProfileInfo& theInfo,
2064 TFileWrapper aFileWrapper(myFile,theMode,theErr, myMinor);
2066 if(theErr && *theErr < 0)
2069 TProfileInfo& anInfo = const_cast<TProfileInfo&>(theInfo);
2070 TValueHolder<TElemNum, med_int> anElemNum(anInfo.myElemNum);
2071 TValueHolder<TString, char> aProfileName(anInfo.myName);
2074 aRet = MEDprofileWr(myFile->Id(), // descripteur du fichier.
2075 &aProfileName, // tableau de valeurs du profil.
2076 theInfo.GetSize(), // taille du profil.
2077 &anElemNum); // nom profil.
2081 EXCEPTION(std::runtime_error,"SetProfileInfo - MEDprofileWr(...)");
2086 ::SetProfileInfo(const TProfileInfo& theInfo,
2090 SetProfileInfo(theInfo,eLECTURE_ECRITURE,&aRet);
2093 SetProfileInfo(theInfo,eLECTURE_AJOUT,&aRet);
2096 SetProfileInfo(theInfo,eCREATION,&aRet);
2102 //-----------------------------------------------------------------
2105 ::GetNbTimeStamps(const MED::TFieldInfo& theInfo,
2106 const MED::TEntityInfo& theEntityInfo,
2107 EEntiteMaillage& theEntity,
2108 TGeom2Size& theGeom2Size,
2111 theEntity = EEntiteMaillage(-1);
2112 TFileWrapper aFileWrapper(myFile,eLECTURE,theErr, myMinor);
2115 if(theEntityInfo.empty())
2119 }else if(theEntityInfo.empty())
2120 EXCEPTION(std::runtime_error,"GetNbTimeStamps - There is no any Entity on the Mesh");
2122 bool anIsPerformAdditionalCheck = GetNbMeshes() > 1;
2124 theGeom2Size.clear();
2125 TInt aNbTimeStamps = 0;
2126 TIdt anId = myFile->Id();
2128 MED::TFieldInfo& anInfo = const_cast<MED::TFieldInfo&>(theInfo);
2129 TValueHolder<TString, char> aFieldName(anInfo.myName);
2130 MED::TMeshInfo& aMeshInfo = anInfo.myMeshInfo;
2132 // workaround for IPAL13676
2133 MED::TEntityInfo localEntityInfo = theEntityInfo;
2134 TEntityInfo::iterator anLocalIter = localEntityInfo.find(eMAILLE);
2135 if(anLocalIter != localEntityInfo.end()){
2136 localEntityInfo[eNOEUD_ELEMENT] = anLocalIter->second;
2139 TEntityInfo::const_iterator anIter = localEntityInfo.begin();
2140 for(; anIter != localEntityInfo.end(); anIter++){
2141 med_entity_type anEntity = med_entity_type(anIter->first);
2142 const TGeom2Size& aGeom2Size = anIter->second;
2143 TGeom2Size::const_iterator anGeomIter = aGeom2Size.begin();
2144 for(; anGeomIter != aGeom2Size.end(); anGeomIter++){
2145 med_geometry_type aGeom = med_geometry_type(anGeomIter->first);
2146 char aMeshName[MED_NAME_SIZE+1];
2149 char dtunit[MED_SNAME_SIZE+1];
2150 med_int myNbComp = MEDfieldnComponentByName(anId,&aFieldName);
2151 char *cname=new char[myNbComp*MED_SNAME_SIZE+1];
2152 char *unitname=new char[myNbComp*MED_SNAME_SIZE+1];
2154 MEDfieldInfoByName(anId,
2171 MEDfieldComputingStepInfo(anId,
2177 char profilename[MED_NAME_SIZE+1];
2178 char locname[MED_NAME_SIZE+1];
2182 // protection from crash (division by zero)
2183 // inside MEDfieldnValueWithProfile function
2184 // caused by the workaround for IPAL13676 (see above)
2185 if( anEntity == MED_NODE_ELEMENT && aGeom % 100 == 0 )
2188 nval = MEDfieldnValueWithProfile(anId,
2193 med_geometry_type(aGeom),
2201 bool anIsSatisfied =(nval > 0);
2204 "GetNbTimeStamps aNbTimeStamps = "<<aNbStamps<<
2205 "; aGeom = "<<aGeom<<"; anEntity = "<<anEntity<<"\n");
2206 if(anIsPerformAdditionalCheck){
2207 anIsSatisfied = !strcmp(&aMeshName[0],&aMeshInfo.myName[0]);
2210 "GetNbTimeStamps aMeshName = '"<<&aMeshName[0]<<"' != "<<
2211 "; aMeshInfo.myName = '"<<&aMeshInfo.myName[0]<<"'\n");
2216 theGeom2Size[EGeometrieElement(aGeom)] = anGeomIter->second;
2217 theEntity = EEntiteMaillage(anEntity);
2218 aNbTimeStamps = aNbStamps;
2221 if(!theGeom2Size.empty())
2224 return aNbTimeStamps;
2228 //----------------------------------------------------------------------------
2231 ::GetTimeStampInfo(TInt theTimeStampId,
2232 MED::TTimeStampInfo& theInfo,
2235 TFileWrapper aFileWrapper(myFile,eLECTURE,theErr, myMinor);
2237 const TGeom2Size& aGeom2Size = theInfo.myGeom2Size;
2240 if(aGeom2Size.empty())
2244 }else if(aGeom2Size.empty())
2245 EXCEPTION(std::runtime_error,"GetTimeStampInfo - There is no any cell");
2247 MED::TFieldInfo& aFieldInfo = *theInfo.myFieldInfo;
2248 MED::TMeshInfo& aMeshInfo = *aFieldInfo.myMeshInfo;
2250 TValueHolder<TString, char> aFieldName(aFieldInfo.myName);
2251 TValueHolder<EEntiteMaillage, med_entity_type> anEntity(theInfo.myEntity);
2252 TValueHolder<TInt, med_int> aNumDt(theInfo.myNumDt);
2253 TValueHolder<TInt, med_int> aNumOrd(theInfo.myNumOrd);
2254 TValueHolder<TString, char> anUnitDt(theInfo.myUnitDt);
2255 TValueHolder<TFloat, med_float> aDt(theInfo.myDt);
2256 TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
2257 TValueHolder<EBooleen, med_bool> anIsLocal(aFieldInfo.myIsLocal);
2258 TValueHolder<TInt, med_int> aNbRef(aFieldInfo.myNbRef);
2260 TGeom2NbGauss& aGeom2NbGauss = theInfo.myGeom2NbGauss;
2262 // just to get a time stamp unit (anUnitDt)
2263 med_field_type aFieldType;
2264 med_int aNbComp = MEDfieldnComponentByName(myFile->Id(), &aFieldName);
2265 char *aCompName = new char[aNbComp*MED_SNAME_SIZE+1];
2266 char *aCompUnit = new char[aNbComp*MED_SNAME_SIZE+1];
2268 MEDfieldInfoByName(myFile->Id(),
2277 delete [] aCompName;
2278 delete [] aCompUnit;
2280 TGeom2Size::const_iterator anIter = aGeom2Size.begin();
2281 for(; anIter != aGeom2Size.end(); anIter++){
2282 const EGeometrieElement& aGeom = anIter->first;
2283 med_int aNbGauss = -1;
2286 aRet = MEDfieldComputingStepInfo(myFile->Id(),
2292 char profilename[MED_NAME_SIZE+1];
2294 char locname[MED_NAME_SIZE+1];
2295 MEDfieldnValueWithProfile(myFile->Id(),
2300 med_geometry_type(aGeom),
2308 static TInt MAX_NB_GAUSS_POINTS = 32;
2309 if(aNbGauss <= 0 || aNbGauss > MAX_NB_GAUSS_POINTS)
2312 aGeom2NbGauss[aGeom] = aNbGauss;
2317 EXCEPTION(std::runtime_error,"GetTimeStampInfo - MEDfieldnValueWithProfile(...)");
2322 //----------------------------------------------------------------------------
2325 ::GetTimeStampValue(const PTimeStampValueBase& theTimeStampValue,
2326 const TMKey2Profile& theMKey2Profile,
2327 const TKey2Gauss& theKey2Gauss,
2330 TFileWrapper aFileWrapper(myFile,eLECTURE,theErr, myMinor);
2332 if(theErr && *theErr < 0)
2335 TIdt anId = myFile->Id();
2337 TValueHolder<EModeSwitch, med_switch_mode> aModeSwitch(theTimeStampValue->myModeSwitch);
2338 MED::TGeom2Profile& aGeom2Profile = theTimeStampValue->myGeom2Profile;
2340 MED::PTimeStampInfo aTimeStampInfo = theTimeStampValue->myTimeStampInfo;
2341 TValueHolder<EEntiteMaillage, med_entity_type> anEntity(aTimeStampInfo->myEntity);
2342 TValueHolder<TInt, med_int> aNumDt(aTimeStampInfo->myNumDt);
2343 TValueHolder<TInt, med_int> aNumOrd(aTimeStampInfo->myNumOrd);
2345 MED::PFieldInfo aFieldInfo = aTimeStampInfo->myFieldInfo;
2346 TValueHolder<TString, char> aFieldName(aFieldInfo->myName);
2347 TValueHolder<EBooleen, med_bool> anIsLocal(aFieldInfo->myIsLocal);
2349 MED::PMeshInfo aMeshInfo = aFieldInfo->myMeshInfo;
2350 TValueHolder<TString, char> aMeshName(aMeshInfo->myName);
2352 TGeom2Gauss& aGeom2Gauss = aTimeStampInfo->myGeom2Gauss;
2353 TVector<char> aGaussName(GetNOMLength<eV2_2>()+1);
2355 med_storage_mode aProfileMode = med_storage_mode(boost::get<0>(theMKey2Profile));
2356 MED::TKey2Profile aKey2Profile = boost::get<1>(theMKey2Profile);
2357 TVector<char> aProfileName(GetNOMLength<eV2_2>()+1);
2359 TGeom2Size& aGeom2Size = aTimeStampInfo->myGeom2Size;
2360 TGeom2Size::iterator anIter = aGeom2Size.begin();
2361 for(; anIter != aGeom2Size.end(); anIter++){
2362 EGeometrieElement aGeom = anIter->first;
2363 TInt aNbElem = anIter->second;
2364 med_int profilesize,aNbGauss;
2366 TInt aNbVal = MEDfieldnValueWithProfile(anId,
2371 med_geometry_type(aGeom),
2384 EXCEPTION(std::runtime_error,"GetTimeStampValue - MEDfieldnValueWithProfile(...) - aNbVal == "<<aNbVal<<" <= 0");
2387 TInt aNbComp = aFieldInfo->myNbComp;
2388 TInt aNbValue = aNbVal;// / aNbGauss; rules in MED changed
2389 theTimeStampValue->AllocateValue(aGeom,
2393 TInt aValueSize = theTimeStampValue->GetValueSize(aGeom);
2396 "TVWrapper::GetTimeStampValue - aGeom = "<<aGeom<<
2397 "; aNbVal = "<<aNbVal<<
2398 "; aNbValue = "<<aNbValue<<
2399 "; aNbGauss = "<<aNbGauss<<
2400 "; aNbComp = "<<aNbComp<<
2403 TErr aRet = MEDfieldValueWithProfileRd(anId,
2408 med_geometry_type(aGeom),
2412 MED_ALL_CONSTITUENT,
2413 theTimeStampValue->GetValuePtr(aGeom));
2416 *theErr = MED_FALSE;
2419 EXCEPTION(std::runtime_error,"GetTimeStampValue - MEDfieldValueWithProfileRd(...)");
2422 MED::PGaussInfo aGaussInfo;
2423 TGaussInfo::TKey aKey(aGeom,&aGaussName[0]);
2424 if(strcmp(&aGaussName[0],"") != 0){
2425 MED::TKey2Gauss::const_iterator anIter = theKey2Gauss.find(aKey);
2426 if(anIter != theKey2Gauss.end()){
2427 aGaussInfo = anIter->second;
2428 aGeom2Gauss[aGeom] = aGaussInfo;
2432 MED::PProfileInfo aProfileInfo;
2433 if(strcmp(&aProfileName[0],MED_NO_PROFILE) != 0){
2434 MED::TKey2Profile::const_iterator anIter = aKey2Profile.find(&aProfileName[0]);
2435 if(anIter != aKey2Profile.end()){
2436 aProfileInfo = anIter->second;
2437 aGeom2Profile[aGeom] = aProfileInfo;
2441 if(aGaussInfo && aNbGauss != aGaussInfo->GetNbGauss()){
2443 *theErr = MED_FALSE;
2446 EXCEPTION(std::runtime_error,"GetTimeStampValue - aNbGauss != aGaussInfo->GetNbGauss()");
2449 if(aProfileInfo && aProfileInfo->IsPresent()){
2450 TInt aNbSubElem = aProfileInfo->GetSize();
2451 TInt aProfileSize = aNbSubElem*aNbComp*aNbGauss;
2452 if(aProfileSize != aValueSize){
2457 EXCEPTION(std::runtime_error,
2458 "GetTimeStampValue - aProfileSize("<<aProfileSize<<
2459 ") != aValueSize("<<aValueSize<<
2460 "); aNbVal = "<<aNbVal<<
2461 "; anEntity = "<<anEntity<<
2462 "; aGeom = "<<aGeom<<
2463 "; aNbElem = "<<aNbElem<<
2464 "; aNbSubElem = "<<aNbSubElem<<
2465 "; aNbComp = "<<aNbComp<<
2466 "; aNbGauss = "<<aNbGauss<<
2470 if((aProfileMode == MED_GLOBAL_STMODE) && (aNbElem != aNbValue)){
2475 EXCEPTION(std::runtime_error,
2476 "GetTimeStampValue - aNbElem("<<aNbElem<<
2477 ") != aNbValue("<<aNbValue<<
2478 "); aNbVal = "<<aNbVal<<
2479 "; anEntity = "<<anEntity<<
2480 "; aGeom = "<<aGeom<<
2481 "; aNbElem = "<<aNbElem<<
2482 "; aNbComp = "<<aNbComp<<
2483 "; aNbGauss = "<<aNbGauss<<
2491 //----------------------------------------------------------------------------
2494 ::SetTimeStampValue(const MED::PTimeStampValueBase& theTimeStampValue,
2498 TFileWrapper aFileWrapper(myFile,theMode,theErr, myMinor);
2500 if(theErr && *theErr < 0)
2504 TIdt anId = myFile->Id();
2506 TValueHolder<EModeSwitch, med_switch_mode> aModeSwitch(theTimeStampValue->myModeSwitch);
2507 MED::TGeom2Profile& aGeom2Profile = theTimeStampValue->myGeom2Profile;
2509 MED::PTimeStampInfo aTimeStampInfo = theTimeStampValue->myTimeStampInfo;
2510 TValueHolder<EEntiteMaillage, med_entity_type> anEntity(aTimeStampInfo->myEntity);
2511 TValueHolder<TInt, med_int> aNumDt(aTimeStampInfo->myNumDt);
2512 TValueHolder<TInt, med_int> aNumOrd(aTimeStampInfo->myNumOrd);
2513 TValueHolder<TString, char> anUnitDt(aTimeStampInfo->myUnitDt);
2514 TValueHolder<TFloat, med_float> aDt(aTimeStampInfo->myDt);
2515 MED::TGeom2Gauss& aGeom2Gauss = aTimeStampInfo->myGeom2Gauss;
2517 MED::PFieldInfo aFieldInfo = aTimeStampInfo->myFieldInfo;
2518 TValueHolder<TString, char> aFieldName(aFieldInfo->myName);
2520 MED::PMeshInfo aMeshInfo = aFieldInfo->myMeshInfo;
2521 TValueHolder<TString, char> aMeshName(aMeshInfo->myName);
2523 const TGeomSet& aGeomSet = theTimeStampValue->myGeomSet;
2524 TGeomSet::const_iterator anIter = aGeomSet.begin();
2525 for(; anIter != aGeomSet.end(); anIter++){
2526 EGeometrieElement aGeom = *anIter;
2528 TVector<char> aGaussName(GetNOMLength<eV2_2>()+1);
2529 MED::TGeom2Gauss::const_iterator aGaussIter = aGeom2Gauss.find(aGeom);
2530 if(aGaussIter != aGeom2Gauss.end()){
2531 MED::PGaussInfo aGaussInfo = aGaussIter->second;
2532 strcpy(&aGaussName[0],&aGaussInfo->myName[0]);
2535 TVector<char> aProfileName(GetNOMLength<eV2_2>()+1);
2536 med_storage_mode aProfileMode = med_storage_mode(eNO_PFLMOD);
2537 MED::TGeom2Profile::const_iterator aProfileIter = aGeom2Profile.find(aGeom);
2538 if(aProfileIter != aGeom2Profile.end()){
2539 MED::PProfileInfo aProfileInfo = aProfileIter->second;
2540 aProfileMode = med_storage_mode(aProfileInfo->myMode);
2541 strcpy(&aProfileName[0],&aProfileInfo->myName[0]);
2544 med_int aNbVal = theTimeStampValue->GetNbVal(aGeom);
2546 aRet = MEDfieldValueWithProfileWr(anId,
2552 med_geometry_type(aGeom),
2557 MED_ALL_CONSTITUENT,
2559 theTimeStampValue->GetValuePtr(aGeom));
2562 *theErr = MED_FALSE;
2565 EXCEPTION(std::runtime_error,"SetTimeStampValue - MEDfieldValueWithProfileWr(...)");
2570 INITMSG(MYDEBUG,"TVWrapper::SetTimeStampValue - MED_MODE_ACCES = "<<theMode<<"; aRet = "<<aRet<<std::endl);
2574 //----------------------------------------------------------------------------
2577 ::SetTimeStampValue(const PTimeStampValueBase& theTimeStampValue,
2581 SetTimeStampValue(theTimeStampValue,eLECTURE_ECRITURE,&aRet);
2584 SetTimeStampValue(theTimeStampValue,eLECTURE_AJOUT,&aRet);
2590 //----------------------------------------------------------------------------
2593 ::SetGrilleInfo(const MED::TGrilleInfo& theInfo,
2596 SetGrilleInfo(theInfo,eLECTURE_ECRITURE,theErr);
2599 //----------------------------------------------------------------------------
2602 ::SetGrilleInfo(const MED::TGrilleInfo& theInfo,
2606 if(theInfo.myMeshInfo->myType != eSTRUCTURE)
2608 TFileWrapper aFileWrapper(myFile,theMode,theErr, myMinor);
2610 if(theErr && *theErr < 0)
2613 MED::TGrilleInfo& anInfo = const_cast<MED::TGrilleInfo&>(theInfo);
2615 MED::TMeshInfo& aMeshInfo = *anInfo.myMeshInfo;
2616 TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
2618 TValueHolder<EGrilleType, med_grid_type > aGrilleType(anInfo.myGrilleType);
2621 aRet = MEDmeshGridTypeRd(myFile->Id(),
2627 EXCEPTION(std::runtime_error,"SetGrilleInfo - MEDmeshGridTypeRd(...)");
2629 if(anInfo.myGrilleType == eGRILLE_STANDARD){
2630 TValueHolder<TNodeCoord, med_float> aCoord(anInfo.myCoord);
2631 TValueHolder<EModeSwitch, med_switch_mode> aModeSwitch(anInfo.myModeSwitch);
2632 TValueHolder<TString, char> aCoordNames(anInfo.myCoordNames);
2633 TValueHolder<TString, char> aCoordUnits(anInfo.myCoordUnits);
2634 med_int aNbNoeuds = med_int(anInfo.myCoord.size() / aMeshInfo.myDim);
2635 //med_axis_type aRepere = MED_CARTESIAN;
2637 aRet = MEDmeshNodeCoordinateWr(myFile->Id(),
2647 EXCEPTION(std::runtime_error,"SetGrilleInfo - MEDmeshNodeCoordinateWr(...)");
2649 TValueHolder<TIntVector, med_int> aGrilleStructure(anInfo.myGrilleStructure);
2650 aRet = MEDmeshGridStructWr(myFile->Id(),
2657 EXCEPTION(std::runtime_error,"SetGrilleInfo - MEDmeshGridStructWr(...)");
2660 for(med_int aAxis = 0; aAxis < aMeshInfo.myDim; aAxis++){
2661 aRet = MEDmeshGridIndexCoordinateWr(myFile->Id(),
2667 anInfo.GetIndexes(aAxis).size(),
2668 &anInfo.GetIndexes(aAxis)[0]);
2671 EXCEPTION(std::runtime_error,"SetGrilleInfo - MEDmeshGridIndexCoordinateWr(...)");
2679 //----------------------------------------------------------------------------
2682 ::GetGrilleInfo(TGrilleInfo& theInfo,
2685 TFileWrapper aFileWrapper(myFile,eLECTURE,theErr, myMinor);
2687 if(theErr && *theErr < 0)
2690 MED::TMeshInfo& aMeshInfo = *theInfo.myMeshInfo;
2691 TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
2692 EMaillage aMaillageType = aMeshInfo.myType;
2694 GetGrilleType(aMeshInfo, theInfo.myGrilleType, theErr);
2695 EGrilleType aGrilleType = theInfo.myGrilleType;
2698 if(aMaillageType == eSTRUCTURE && aGrilleType == eGRILLE_STANDARD) {
2699 GetGrilleStruct(aMeshInfo, theInfo.myGrilleStructure, theErr);
2701 TValueHolder<TNodeCoord, med_float> aCoord(theInfo.myCoord);
2702 TValueHolder<EModeSwitch, med_switch_mode> aModeSwitch(theInfo.myModeSwitch);
2703 TValueHolder<TString, char> aCoordNames(theInfo.myCoordNames);
2704 TValueHolder<TString, char> aCoordUnits(theInfo.myCoordUnits);
2705 //med_axis_type aRepere;
2707 aRet = MEDmeshNodeCoordinateRd(myFile->Id(),
2717 EXCEPTION(std::runtime_error,"GetGrilleInfo - MEDmeshNodeCoordinateRd(...)");
2719 //TInt aNbNodes = theInfo.GetNbNodes();//GetNbFamilies(aMeshInfo);
2720 TValueHolder<TElemNum, med_int> aFamNumNode(theInfo.myFamNumNode);
2722 aRet = MEDmeshEntityFamilyNumberRd(myFile->Id(),
2732 // if (aRet == MED_ERR_DOESNTEXIST) // --- only valid with MED3.x files
2734 int mySize = (int)theInfo.myFamNumNode.size();
2735 theInfo.myFamNumNode.clear();
2736 theInfo.myFamNumNode.resize(mySize,0);
2740 // EXCEPTION(std::runtime_error,"GetGrilleInfo - MEDmeshEntityFamilyNumberRd(...)");
2745 //============================
2748 if(aMaillageType == eSTRUCTURE && aGrilleType != eGRILLE_STANDARD){
2749 ETable aTable = eCOOR_IND1;
2750 for(med_int anAxis = 1; anAxis <= aMeshInfo.myDim; anAxis++){
2753 aTable = eCOOR_IND1;
2756 aTable = eCOOR_IND2;
2759 aTable = eCOOR_IND3;
2768 EXCEPTION(std::runtime_error,"GetGrilleInfo - anAxis number out of range(...)");
2770 TInt aNbIndexes = GetNbNodes(aMeshInfo,aTable);
2772 EXCEPTION(std::runtime_error,"GetGrilleInfo - Erreur a la lecture de la taille de l'indice");
2774 TValueHolder<TFloatVector, med_float> anIndexes(theInfo.GetIndexes(anAxis-1));
2775 //TValueHolder<ETable, med_data_type > table(aTable);
2776 //char aCompNames[MED_SNAME_SIZE+1];
2777 //char anUnitNames[MED_SNAME_SIZE+1];
2778 aRet=MEDmeshGridIndexCoordinateRd(myFile->Id(),&aMeshName,
2779 MED_NO_DT,MED_NO_IT,
2783 //theInfo.SetCoordName(anAxis-1, aCompNames);
2784 //theInfo.SetCoordUnit(anAxis-1, anUnitNames);
2785 theInfo.SetGrilleStructure(anAxis-1, aNbIndexes);
2790 EXCEPTION(std::runtime_error,"GetGrilleInfo - MEDindicesCoordLire(...)");
2794 EGeometrieElement aGeom = theInfo.GetGeom();
2795 EEntiteMaillage aEntity = theInfo.GetEntity();
2796 TInt aNbCells = theInfo.GetNbCells();
2798 theInfo.myFamNum.resize(aNbCells);
2799 TValueHolder<TElemNum, med_int> aFamNum(theInfo.myFamNum);
2801 aRet = MEDmeshEntityFamilyNumberRd(myFile->Id(),
2802 &aMeshName,MED_NO_DT,MED_NO_IT,med_entity_type(aEntity),
2803 med_geometry_type(aGeom),&aFamNum);
2805 if ( aMeshInfo.myDim == 3 )
2807 aGeom = theInfo.GetSubGeom();
2808 aEntity = theInfo.GetSubEntity();
2809 aNbCells = theInfo.GetNbSubCells();
2811 theInfo.myFamSubNum.resize(aNbCells,0);
2812 TValueHolder<TElemNum, med_int> aFamNum(theInfo.myFamSubNum);
2814 aRet = MEDmeshEntityFamilyNumberRd(myFile->Id(),
2815 &aMeshName,MED_NO_DT,MED_NO_IT,
2816 med_entity_type(aEntity),
2817 med_geometry_type(aGeom),&aFamNum);
2821 // if (aRet == MED_ERR_DOESNTEXIST) // --- only valid with MED3.x files
2823 int mySize = (int)theInfo.myFamNumNode.size();
2824 theInfo.myFamNumNode.clear();
2825 theInfo.myFamNumNode.resize(mySize,0);
2829 // EXCEPTION(std::runtime_error,"GetGrilleInfo - MEDmeshEntityFamilyNumberRd(...)");
2837 ::GetGrilleType(const MED::TMeshInfo& theMeshInfo,
2838 EGrilleType& theGridType,
2841 TFileWrapper aFileWrapper(myFile,eLECTURE,theErr, myMinor);
2843 if(theErr && *theErr < 0)
2844 EXCEPTION(std::runtime_error," GetGrilleType - aFileWrapper (...)");
2846 MED::TMeshInfo& aMeshInfo = const_cast<MED::TMeshInfo&>(theMeshInfo);
2848 if(aMeshInfo.myType == eSTRUCTURE){
2849 TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
2850 TValueHolder<EGrilleType, med_grid_type> aGridType(theGridType);
2851 TErr aRet = MEDmeshGridTypeRd(myFile->Id(),
2856 EXCEPTION(std::runtime_error,"GetGrilleInfo - MEDmeshGridTypeRd(...)");
2862 ::GetGrilleStruct(const MED::TMeshInfo& theMeshInfo,
2863 TIntVector& theStruct,
2866 TFileWrapper aFileWrapper(myFile,eLECTURE,theErr, myMinor);
2868 if(theErr && *theErr < 0)
2872 MED::TMeshInfo& aMeshInfo = const_cast<MED::TMeshInfo&>(theMeshInfo);
2874 TValueHolder<TString, char> aMeshName(aMeshInfo.myName);
2875 TValueHolder<TIntVector, med_int> aGridStructure(theStruct);
2877 aRet = MEDmeshGridStructRd(myFile->Id(),
2885 EXCEPTION(std::runtime_error,"GetGrilleInfo - MEDmeshGridStructRd(...)");