3 // Copyright (C) 2003 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.
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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
29 #ifndef MED_TStructures_HeaderFile
30 #define MED_TStructures_HeaderFile
32 #include "MED_Structures.hxx"
36 const TInt DESC = 200;
41 //---------------------------------------------------------------
42 template<TInt nPNOM, TInt nDESC, TInt nIDENT, TInt nNOM, TInt nLNOM, EVersion nV>
43 struct TTNameInfo: virtual TNameInfo
45 TTNameInfo(const std::string& theValue = "")
47 myName.resize(nNOM+1);
51 virtual std::string GetName() const {
52 return GetString(0,nNOM,myName);
55 virtual void SetName(const std::string& theValue){
56 SetString(0,nNOM,myName,theValue);
61 //---------------------------------------------------------------
62 template<TInt nPNOM, TInt nDESC, TInt nIDENT, TInt nNOM, TInt nLNOM, EVersion nV>
65 virtual TTNameInfo<nPNOM,nDESC,nIDENT,nNOM,nLNOM,nV>
67 typedef TTNameInfo<nPNOM,nDESC,nIDENT,nNOM,nLNOM,nV> TNameInfoBase;
69 TTMeshInfo(const PMeshInfo& theInfo):
70 TNameInfoBase(theInfo->GetName())
72 myDim = theInfo->GetDim();
73 myType = theInfo->GetType();
75 myDesc.resize(nDESC+1);
76 SetDesc(theInfo->GetDesc());
79 TTMeshInfo(TInt theDim = 0,
80 const std::string& theValue = "",
81 EMaillage theType = eNON_STRUCTURE,
82 const std::string& theDesc = ""):
83 TNameInfoBase(theValue)
88 myDesc.resize(nDESC+1);
92 virtual std::string GetDesc() const {
93 return GetString(0,nDESC,myDesc);
96 virtual void SetDesc(const std::string& theValue){
97 SetString(0,nDESC,myDesc,theValue);
102 //---------------------------------------------------------------
103 template<TInt nPNOM, TInt nDESC, TInt nIDENT, TInt nNOM, TInt nLNOM, EVersion nV>
106 virtual TTNameInfo<nPNOM,nDESC,nIDENT,nNOM,nLNOM,nV>
108 typedef TTNameInfo<nPNOM,nDESC,nIDENT,nNOM,nLNOM,nV> TNameInfoBase;
110 TTFamilyInfo(const PMeshInfo& theMeshInfo, const PFamilyInfo& theInfo):
111 TNameInfoBase(theInfo->GetName())
113 myMeshInfo = theMeshInfo;
115 myId = theInfo->GetId();
117 myNbGroup = theInfo->GetNbGroup();
118 myGroupNames.resize(myNbGroup*nLNOM+1);
120 for(TInt anId = 0; anId < myNbGroup; anId++){
121 SetGroupName(anId,theInfo->GetGroupName(anId));
125 myNbAttr = theInfo->GetNbAttr();
126 myAttrId.resize(myNbAttr);
127 myAttrVal.resize(myNbAttr);
128 myAttrDesc.resize(myNbAttr*nDESC+1);
130 for(TInt anId = 0; anId < myNbAttr; anId++){
131 SetAttrDesc(anId,theInfo->GetAttrDesc(anId));
132 myAttrVal[anId] = theInfo->GetAttrVal(anId);
133 myAttrId[anId] = theInfo->GetAttrId(anId);
138 TTFamilyInfo(const PMeshInfo& theMeshInfo,
142 const std::string& theValue = ""):
143 TNameInfoBase(theValue)
145 myMeshInfo = theMeshInfo;
149 myNbGroup = theNbGroup;
150 myGroupNames.resize(theNbGroup*nLNOM+1);
152 myNbAttr = theNbAttr;
153 myAttrId.resize(theNbAttr);
154 myAttrVal.resize(theNbAttr);
155 myAttrDesc.resize(theNbAttr*nDESC+1);
158 TTFamilyInfo(const PMeshInfo& theMeshInfo,
159 const std::string& theValue,
161 const TStringSet& theGroupNames,
162 const TStringVector& theAttrDescs = TStringVector(),
163 const TIntVector& theAttrIds = TIntVector(),
164 const TIntVector& theAttrVals = TIntVector()):
165 TNameInfoBase(theValue)
167 myMeshInfo = theMeshInfo;
171 myNbGroup = theGroupNames.size();
172 myGroupNames.resize(myNbGroup*nLNOM+1);
174 TStringSet::const_iterator anIter = theGroupNames.begin();
175 for(TInt anId = 0; anIter != theGroupNames.end(); anIter++, anId++){
176 const std::string& aVal = *anIter;
177 SetGroupName(anId,aVal);
181 myNbAttr = theAttrDescs.size();
182 myAttrId.resize(myNbAttr);
183 myAttrVal.resize(myNbAttr);
184 myAttrDesc.resize(myNbAttr*nDESC+1);
186 for(TInt anId = 0, anEnd = theAttrDescs.size(); anId < anEnd; anId++){
187 SetAttrDesc(anId,theAttrDescs[anId]);
188 myAttrVal[anId] = theAttrVals[anId];
189 myAttrId[anId] = theAttrIds[anId];
194 virtual std::string GetGroupName(TInt theId) const {
195 return GetString(theId,nLNOM,myGroupNames);
198 virtual void SetGroupName(TInt theId, const std::string& theValue){
199 SetString(theId,nLNOM,myGroupNames,theValue);
202 virtual std::string GetAttrDesc(TInt theId) const {
203 return GetString(theId,nDESC,myAttrDesc);
206 virtual void SetAttrDesc(TInt theId, const std::string& theValue){
207 SetString(theId,nDESC,myAttrDesc,theValue);
212 //---------------------------------------------------------------
213 template<TInt nPNOM, TInt nDESC, TInt nIDENT, TInt nNOM, TInt nLNOM, EVersion nV>
214 struct TTElemInfo: virtual TElemInfo
216 TTElemInfo(const PMeshInfo& theMeshInfo, const PElemInfo& theInfo)
218 myMeshInfo = theMeshInfo;
220 myNbElem = theInfo->GetNbElem();
221 myFamNum.resize(myNbElem);
223 myIsElemNum = theInfo->IsElemNum();
224 myElemNum.resize(myIsElemNum == eFAUX? 0: myNbElem);
226 myIsElemNames = theInfo->IsElemNames();
227 myElemNames.resize(myNbElem*nPNOM+1);
230 for(TInt anId = 0; anId < myNbElem; anId++){
231 myFamNum[anId] = theInfo->GetFamNum(anId);
233 if(myIsElemNum == eVRAI){
234 for(TInt anId = 0; anId < myNbElem; anId++){
235 myElemNum[anId] = theInfo->GetElemNum(anId);
238 if(myIsElemNames == eVRAI){
239 for(TInt anId = 0; anId < myNbElem; anId++){
240 SetElemName(anId,theInfo->GetElemName(anId));
246 TTElemInfo(const PMeshInfo& theMeshInfo,
248 EBooleen theIsElemNum = eVRAI,
249 EBooleen theIsElemNames = eVRAI)
251 myMeshInfo = theMeshInfo;
253 myNbElem = theNbElem;
254 myFamNum.resize(theNbElem);
256 myIsElemNum = theIsElemNum;
257 myElemNum.resize(theIsElemNum == eFAUX? 0: theNbElem);
259 myIsElemNames = theIsElemNames;
260 myElemNames.resize(theNbElem*nPNOM+1);
263 TTElemInfo(const PMeshInfo& theMeshInfo,
264 const TIntVector& theFamilyNums,
265 const TIntVector& theElemNums,
266 const TStringVector& theElemNames = TStringVector())
268 myMeshInfo = theMeshInfo;
270 myNbElem = theFamilyNums.size();
271 myFamNum.resize(myNbElem);
273 myIsElemNum = theElemNums.size()? eVRAI: eFAUX;
274 myElemNum.resize(theElemNums.size());
276 myIsElemNames = theElemNames.size()? eVRAI: eFAUX;
277 myElemNames.resize(theElemNames.size()*nPNOM+1);
280 for(TInt anId = 0; anId < myNbElem; anId++){
281 myFamNum[anId] = theFamilyNums[anId];
283 if(myIsElemNum == eVRAI){
284 for(TInt anId = 0; anId < myNbElem; anId++){
285 myElemNum[anId] = theElemNums[anId];
288 if(myIsElemNames == eVRAI){
289 for(TInt anId = 0; anId < myNbElem; anId++){
290 const std::string& aVal = theElemNames[anId];
291 SetElemName(anId,aVal);
297 virtual std::string GetElemName(TInt theId) const {
298 return GetString(theId,nPNOM,myElemNames);
301 virtual void SetElemName(TInt theId, const std::string& theValue){
302 SetString(theId,nPNOM,myElemNames,theValue);
307 //---------------------------------------------------------------
308 template<TInt nPNOM, TInt nDESC, TInt nIDENT, TInt nNOM, TInt nLNOM, EVersion nV>
311 virtual TTElemInfo<nPNOM,nDESC,nIDENT,nNOM,nLNOM,nV>
313 typedef TTElemInfo<nPNOM,nDESC,nIDENT,nNOM,nLNOM,nV> TElemInfoBase;
315 TTNodeInfo(const PMeshInfo& theMeshInfo, const PNodeInfo& theInfo):
316 TElemInfoBase(theMeshInfo,theInfo)
318 mySystem = theInfo->GetSystem();
320 TInt aDim = theMeshInfo->GetDim();
321 TInt aNbElem = theInfo->GetNbElem();
322 myCoord.resize(aNbElem*aDim);
324 for(TInt anElemId = 0; anElemId < aNbElem; anElemId++){
325 for(TInt anDimId = 0; anDimId < aDim; anDimId++){
326 SetNodeCoord(anElemId,anDimId,theInfo->GetNodeCoord(anElemId,anDimId));
330 myCoordNames.resize(aDim*nPNOM+1);
331 for(TInt anId = 0; anId < aDim; anId++){
332 SetCoordName(anId,theInfo->GetCoordName(anId));
335 myCoordUnits.resize(aDim*nPNOM+1);
336 for(TInt anId = 0; anId < aDim; anId++){
337 SetCoordUnit(anId,theInfo->GetCoordUnit(anId));
341 TTNodeInfo(const PMeshInfo& theMeshInfo,
343 ERepere theSystem = eCART,
344 EBooleen theIsElemNum = eVRAI,
345 EBooleen theIsElemNames = eVRAI):
346 TElemInfoBase(theMeshInfo,
351 mySystem = theSystem;
352 myCoord.resize(theNbElem*theMeshInfo->myDim);
353 myCoordNames.resize(theMeshInfo->myDim*nPNOM+1);
354 myCoordUnits.resize(theMeshInfo->myDim*nPNOM+1);
358 TTNodeInfo(const PMeshInfo& theMeshInfo,
360 const TFloatVector& theNodeCoords,
361 const TStringVector& theCoordNames,
362 const TStringVector& theCoordUnits,
363 const TIntVector& theFamilyNums,
364 const TIntVector& theElemNums,
365 const TStringVector& theElemNames = TStringVector()):
366 TElemInfoBase(theMeshInfo,
371 mySystem = theSystem;
372 myCoord.resize(theNodeCoords.size());
374 for(TInt anId = 0, anEnd = myCoord.size(); anId < anEnd; anId++){
375 myCoord[anId] = theNodeCoords[anId];
378 TInt aDim = theMeshInfo->GetDim();
379 myCoordNames.resize(aDim*nPNOM+1);
380 for(TInt anId = 0; anId < aDim; anId++){
381 SetCoordName(anId,theCoordNames[anId]);
384 myCoordUnits.resize(aDim*nPNOM+1);
385 for(TInt anId = 0; anId < aDim; anId++){
386 SetCoordUnit(anId,theCoordUnits[anId]);
390 virtual std::string GetCoordName(TInt theId) const {
391 return GetString(theId,nPNOM,myCoordNames);
394 virtual void SetCoordName(TInt theId, const std::string& theValue){
395 SetString(theId,nPNOM,myCoordNames,theValue);
398 virtual std::string GetCoordUnit(TInt theId) const {
399 return GetString(theId,nPNOM,myCoordUnits);
402 virtual void SetCoordUnit(TInt theId, const std::string& theValue){
403 SetString(theId,nPNOM,myCoordUnits,theValue);
407 //---------------------------------------------------------------
408 template<TInt nPNOM, TInt nDESC, TInt nIDENT, TInt nNOM, TInt nLNOM, EVersion nV>
409 struct TTPolygoneInfo:
410 virtual TPolygoneInfo,
411 virtual TTElemInfo<nPNOM,nDESC,nIDENT,nNOM,nLNOM,nV>
413 typedef TTElemInfo<nPNOM,nDESC,nIDENT,nNOM,nLNOM,nV> TElemInfoBase;
415 TTPolygoneInfo(const PMeshInfo& theMeshInfo, const PPolygoneInfo& theInfo):
416 TElemInfoBase(theMeshInfo,theInfo)
418 myTEntity = theInfo->GetEntity();
419 myTGeom = theInfo->GetGeom();
420 myTConn = theInfo->GetConn();
421 myConnDim = theInfo->GetConnDim();
422 myConn = theInfo->GetConnectivite();
423 myIndex = theInfo->GetIndex();
426 TTPolygoneInfo(const PMeshInfo& theMeshInfo,
429 EEntiteMaillage theTEntity,
430 EGeometrieElement theTGeom,
431 EConnectivite theTConn = eNOD,
432 EBooleen theIsElemNum = eVRAI,
433 EBooleen theIsElemNames = eVRAI):
434 TElemInfoBase(theMeshInfo,
439 myTEntity = theTEntity;
442 myConnDim = theNbConn;
443 myConn.resize(myConnDim);
444 myIndex.resize(theNbElem+1);
447 TTPolygoneInfo(const PMeshInfo& theMeshInfo,
448 EEntiteMaillage theTEntity,
449 EGeometrieElement theTGeom,
450 EConnectivite theTConn,
451 const TIntVector& theConnectivities,
452 const TIntVector& theIndexes,
453 const TIntVector& theFamilyNums,
454 const TIntVector& theElemNums,
455 const TStringVector& theElemNames = TStringVector()):
456 TElemInfoBase(theMeshInfo,
461 myTEntity = theTEntity;
464 myConnDim = theConnectivities.size();
465 myConn = theConnectivities;
466 myIndex = theIndexes;
470 //---------------------------------------------------------------
471 template<TInt nPNOM, TInt nDESC, TInt nIDENT, TInt nNOM, TInt nLNOM, EVersion nV>
472 struct TTPolyedreInfo:
473 virtual TPolyedreInfo,
474 virtual TTElemInfo<nPNOM,nDESC,nIDENT,nNOM,nLNOM,nV>
476 typedef TTElemInfo<nPNOM,nDESC,nIDENT,nNOM,nLNOM,nV> TElemInfoBase;
478 TTPolyedreInfo(const PMeshInfo& theMeshInfo, const PPolyedreInfo& theInfo):
479 TElemInfoBase(theMeshInfo,theInfo)
481 myTEntity = theInfo->GetEntity();
482 myTGeom = theInfo->GetGeom();
483 myTConn = theInfo->GetConn();
484 myNbConn = theInfo->GetNbConn();
485 myNbFacesIndex = theInfo->GetNbFacesIndex();
486 myConn = theInfo->GetConnectivite();
487 myFacesIndex = theInfo->GetFacesIndex();
488 myIndex = theInfo->GetIndex();
491 TTPolyedreInfo(const PMeshInfo& theMeshInfo,
494 TInt theNbFacesIndex,
495 EEntiteMaillage theTEntity,
496 EGeometrieElement theTGeom,
497 EConnectivite theTConn = eNOD,
498 EBooleen theIsElemNum = eVRAI,
499 EBooleen theIsElemNames = eVRAI):
500 TElemInfoBase(theMeshInfo,
505 myTEntity = theTEntity;
508 myNbConn = theNbConn;
509 myNbFacesIndex = theNbFacesIndex;
510 myConn.resize(myNbConn);
511 myFacesIndex.resize(myNbFacesIndex);
512 myIndex.resize(theNbElem+1);
515 TTPolyedreInfo(const PMeshInfo& theMeshInfo,
516 EEntiteMaillage theTEntity,
517 EGeometrieElement theTGeom,
518 EConnectivite theTConn,
519 const TIntVector& theConnectivities,
520 const TIntVector& theFacesIndexes,
521 const TIntVector& theIndexes,
522 const TIntVector& theFamilyNums,
523 const TIntVector& theElemNums,
524 const TStringVector& theElemNames = TStringVector()):
525 TElemInfoBase(theMeshInfo,
530 myTEntity = theTEntity;
533 myNbConn = theConnectivities.size();
534 myNbFacesIndex = theFacesIndexes.size();
535 myConn = theConnectivities;
536 myFacesIndex = theFacesIndexes;
537 myIndex = theIndexes;
541 //---------------------------------------------------------------
542 template<TInt nPNOM, TInt nDESC, TInt nIDENT, TInt nNOM, TInt nLNOM, EVersion nV>
545 virtual TTElemInfo<nPNOM,nDESC,nIDENT,nNOM,nLNOM,nV>
547 typedef TTElemInfo<nPNOM,nDESC,nIDENT,nNOM,nLNOM,nV> TElemInfoBase;
549 TTCellInfo(const PMeshInfo& theMeshInfo, const PCellInfo& theInfo):
550 TElemInfoBase(theMeshInfo,theInfo)
552 myTEntity = theInfo->GetEntity();
553 myTGeom = theInfo->GetGeom();
554 myTConn = theInfo->GetConn();
556 TInt aConnDim = GetNbNodes(myTGeom);
557 myConn.resize(myNbElem*GetNbConn<nV>(myTGeom,myTEntity,myMeshInfo->myDim));
558 for(TInt anElemId = 0; anElemId < myNbElem; anElemId++){
559 for(TInt anConnId = 0; anConnId < aConnDim; anConnId++){
560 SetConn(anElemId,anConnId,theInfo->GetConn(anElemId,anConnId));
565 TTCellInfo(const PMeshInfo& theMeshInfo,
567 EEntiteMaillage theTEntity,
568 EGeometrieElement theTGeom,
569 EConnectivite theTConn = eNOD,
570 EBooleen theIsElemNum = eVRAI,
571 EBooleen theIsElemNames = eVRAI):
572 TElemInfoBase(theMeshInfo,
577 myTEntity = theTEntity;
580 myConn.resize(theNbElem*GetNbConn<nV>(theTGeom,myTEntity,theMeshInfo->myDim));
583 TTCellInfo(const PMeshInfo& theMeshInfo,
584 EEntiteMaillage theTEntity,
585 EGeometrieElement theTGeom,
586 EConnectivite theTConn,
587 const TIntVector& theConnectivities,
588 const TIntVector& theFamilyNums,
589 const TIntVector& theElemNums,
590 const TStringVector& theElemNames = TStringVector()):
591 TElemInfoBase(theMeshInfo,
596 myTEntity = theTEntity;
600 TInt aConnDim = GetNbNodes(myTGeom);
601 myNbElem = theConnectivities.size() / aConnDim;
602 myConn.resize(myNbElem*GetNbConn<nV>(myTGeom,myTEntity,myMeshInfo->myDim));
603 for(TInt anElemId = 0; anElemId < myNbElem; anElemId++){
604 for(TInt anConnId = 0; anConnId < aConnDim; anConnId++){
605 SetConn(anElemId,anConnId,theConnectivities[anElemId*aConnDim+anConnId]);
611 virtual TInt GetConnDim() const {
612 return GetNbConn<nV>(myTGeom,myTEntity,myMeshInfo->myDim);
618 //---------------------------------------------------------------
619 template<TInt nPNOM, TInt nDESC, TInt nIDENT, TInt nNOM, TInt nLNOM, EVersion nV>
622 virtual TTNameInfo<nPNOM,nDESC,nIDENT,nNOM,nLNOM,nV>
624 typedef TTNameInfo<nPNOM,nDESC,nIDENT,nNOM,nLNOM,nV> TNameInfoBase;
626 TTFieldInfo(const PMeshInfo& theMeshInfo, const PFieldInfo& theInfo):
627 TNameInfoBase(theInfo->GetName())
629 myMeshInfo = theMeshInfo;
631 myNbComp = theInfo->GetNbComp();
632 myCompNames.resize(myNbComp*nPNOM+1);
633 for(TInt anId = 0; anId < myNbComp; anId++){
634 SetCompName(anId,theInfo->GetCompName(anId));
637 myUnitNames.resize(myNbComp*nPNOM+1);
638 for(TInt anId = 0; anId < myNbComp; anId++){
639 SetUnitName(anId,theInfo->GetUnitName(anId));
642 myType = theInfo->GetType();
644 myIsLocal = theInfo->GetIsLocal();
645 myNbRef = theInfo->GetNbRef();
648 TTFieldInfo(const PMeshInfo& theMeshInfo,
650 ETypeChamp theType = eFLOAT64,
651 const std::string& theValue = "",
652 EBooleen theIsLocal = eVRAI,
654 TNameInfoBase(theValue)
656 myMeshInfo = theMeshInfo;
658 myNbComp = theNbComp;
659 myCompNames.resize(theNbComp*nPNOM+1);
660 myUnitNames.resize(theNbComp*nPNOM+1);
664 myIsLocal = theIsLocal;
668 virtual std::string GetCompName(TInt theId) const {
669 return GetString(theId,nPNOM,myCompNames);
672 virtual void SetCompName(TInt theId, const std::string& theValue){
673 SetString(theId,nPNOM,myCompNames,theValue);
676 virtual std::string GetUnitName(TInt theId) const {
677 return GetString(theId,nPNOM,myUnitNames);
680 virtual void SetUnitName(TInt theId, const std::string& theValue){
681 SetString(theId,nPNOM,myUnitNames,theValue);
686 //---------------------------------------------------------------
687 template<TInt nPNOM, TInt nDESC, TInt nIDENT, TInt nNOM, TInt nLNOM, EVersion nV>
688 struct TTTimeStampInfo: virtual TTimeStampInfo
690 TTTimeStampInfo(const PFieldInfo& theFieldInfo, const PTimeStampInfo& theInfo)
692 myFieldInfo = theFieldInfo;
694 myEntity = theInfo->GetEntity();
695 myGeom = theInfo->GetGeom();
697 myNbGauss = theInfo->GetNbGauss();
698 myNumDt = theInfo->GetNumDt();
699 myNumOrd = theInfo->GetNumOrd();
700 myDt = theInfo->GetDt();
702 myUnitDt.resize(nPNOM+1);
703 SetUnitDt(theInfo->GetUnitDt());
705 myGaussName.resize(nNOM+1);
706 SetGaussName(theInfo->GetGaussName());
709 TTTimeStampInfo(const PFieldInfo& theFieldInfo,
710 EEntiteMaillage theEntity,
711 const TGeom& theGeom,
716 const std::string& theUnitDt = "",
717 const std::string& theGaussName = "")
719 myFieldInfo = theFieldInfo;
721 myEntity = theEntity;
724 myNbGauss = theNbGauss;
729 myUnitDt.resize(nPNOM+1);
730 SetUnitDt(theUnitDt);
732 myGaussName.resize(nNOM+1);
733 SetGaussName(theGaussName);
736 virtual std::string GetGaussName() const {
737 return GetString(0,nNOM,myGaussName);
740 virtual void SetGaussName(const std::string& theValue){
741 SetString(0,nNOM,myGaussName,theValue);
744 virtual std::string GetUnitDt() const {
745 return GetString(0,nPNOM,myUnitDt);
748 virtual void SetUnitDt(const std::string& theValue){
749 SetString(0,nPNOM,myUnitDt,theValue);
754 //---------------------------------------------------------------
755 template<TInt nPNOM, TInt nDESC, TInt nIDENT, TInt nNOM, TInt nLNOM, EVersion nV>
756 struct TTTimeStampVal: virtual TTimeStampVal
758 TTTimeStampVal(const PTimeStampInfo& theTimeStampInfo, const PTimeStampVal& theInfo)
760 myTimeStampInfo = theTimeStampInfo;
762 myPflMode = theInfo->GetPflMode();
764 myPflName.resize(nNOM+1);
765 SetPflName(theInfo->GetPflName());
767 TInt aNbComp = theTimeStampInfo->GetFieldInfo()->GetNbComp();
768 const TGeom& aTGeom = theTimeStampInfo->GetGeom();
769 TInt aNbGauss = theTimeStampInfo->GetNbGauss();
770 TGeom::const_iterator anIter = aTGeom.begin();
771 for(; anIter != aTGeom.end(); anIter++){
772 const EGeometrieElement& aGeom = anIter->first;
773 TInt aNbElem = anIter->second;
774 TInt aSize = aNbElem*aNbComp*aNbGauss;
775 TValue& aValue = myMeshValue[aGeom];
776 aValue.resize(aSize);
777 for(TInt anElemId = 0; anElemId < aNbElem; anElemId++){
778 for(TInt aCompId = 0; aCompId < aNbComp; aCompId++){
779 for(TInt aGaussId = 0; aGaussId < aNbGauss; aGaussId++){
780 SetVal(aGeom,anElemId,aCompId,theInfo->GetVal(aGeom,anElemId,aCompId,aGaussId),aGaussId);
787 TTTimeStampVal(const PTimeStampInfo& theTimeStampInfo,
788 const std::string& thePflName = "",
789 EModeProfil thePflMode = eCOMPACT)
791 myTimeStampInfo = theTimeStampInfo;
793 myPflMode = thePflMode;
795 myPflName.resize(nNOM+1);
796 SetPflName(thePflName);
798 TInt aNbComp = theTimeStampInfo->myFieldInfo->myNbComp;
799 TInt aNbGauss = theTimeStampInfo->myNbGauss;
800 const TGeom& aTGeom = theTimeStampInfo->myGeom;
801 TGeom::const_iterator anIter = aTGeom.begin();
802 for(; anIter != aTGeom.end(); anIter++){
803 const EGeometrieElement& aGeom = anIter->first;
804 TInt aNb = anIter->second*aNbComp*aNbGauss;
805 myMeshValue[aGeom].resize(aNb);
809 virtual std::string GetPflName() const {
810 return GetString(0,nNOM,myPflName);
813 virtual void SetPflName(const std::string& theValue){
814 SetString(0,nNOM,myPflName,theValue);