Version: 8.3.0
MED_Structures.hxx
Go to the documentation of this file.
1 // Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
2 //
3 // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
5 //
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.
10 //
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.
15 //
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
19 //
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
21 //
22 
23 #ifndef MED_Structures_HeaderFile
24 #define MED_Structures_HeaderFile
25 
26 #include "MED_Common.hxx"
27 #include "MED_Utilities.hxx"
28 
29 #ifdef WIN32
30 #pragma warning(disable:4251)
31 #endif
32 
33 namespace MED
34 {
35 
36  //---------------------------------------------------------------
38  typedef TVector<char> TString;
39  typedef SharedPtr<TString> PString;
40 
42  MEDWRAPPER_EXPORT
43  std::string
44  GetString(TInt theId, TInt theStep,
45  const TString& theString);
46 
48  MEDWRAPPER_EXPORT
49  void
50  SetString(TInt theId, TInt theStep,
51  TString& theString,
52  const std::string& theValue);
53 
55  MEDWRAPPER_EXPORT
56  void
57  SetString(TInt theId, TInt theStep,
58  TString& theString,
59  const TString& theValue);
60 
61  //---------------------------------------------------------------
63  struct MEDWRAPPER_EXPORT TBase
64  {
65  virtual ~TBase() {}
66  };
67 
68 
69  //---------------------------------------------------------------
71  struct MEDWRAPPER_EXPORT TNameInfo: virtual TBase
72  {
73  TString myName;
74  virtual std::string GetName() const = 0;
75  virtual void SetName(const std::string& theValue) = 0;
76  virtual void SetName(const TString& theValue) = 0;
77  };
78 
79 
80  //---------------------------------------------------------------
82 
86  struct MEDWRAPPER_EXPORT TModeSwitchInfo: virtual TBase
87  {
89  TModeSwitchInfo():
90  myModeSwitch(eFULL_INTERLACE)
91  {}
92 
94  TModeSwitchInfo(EModeSwitch theModeSwitch):
95  myModeSwitch(theModeSwitch)
96  {}
97 
98  EModeSwitch myModeSwitch;
99  EModeSwitch GetModeSwitch() const { return myModeSwitch;}
100  };
101 
102 
103  //---------------------------------------------------------------
105  struct MEDWRAPPER_EXPORT TMeshInfo: virtual TNameInfo
106  {
107  TInt myDim;
108  TInt GetDim() const { return myDim;}
109 
110  TInt mySpaceDim;
111  TInt GetSpaceDim() const { return mySpaceDim; }
112 
113  EMaillage myType;
114  EMaillage GetType() const { return myType;}
115 
116  TString myDesc;
117  virtual std::string GetDesc() const = 0;
118  virtual void SetDesc(const std::string& theValue) = 0;
119 
120 
121  };
122 
123 
124  //---------------------------------------------------------------
125  typedef TVector<TInt> TIntVector;
126  typedef TSlice<TInt> TIntVecSlice;
127  typedef TCSlice<TInt> TCIntVecSlice;
128 
129  typedef TIntVector TFamAttr;
130 
132  struct MEDWRAPPER_EXPORT TFamilyInfo: virtual TNameInfo
133  {
134  PMeshInfo myMeshInfo;
135 
136  const PMeshInfo& GetMeshInfo() const { return myMeshInfo;}
137 
138  TInt myId;
139  TInt GetId() const { return myId;}
140  void SetId(TInt theId) { myId = theId;}
141 
142  TInt myNbGroup;
143 
144  TInt GetNbGroup() const { return myNbGroup;}
145 
147  TString myGroupNames;
149  virtual std::string GetGroupName(TInt theId) const = 0;
151  virtual void SetGroupName(TInt theId, const std::string& theValue) = 0;
152 
153  TInt myNbAttr;
154 
155  TInt GetNbAttr() const { return myNbAttr;}
156 
158  TFamAttr myAttrId;
160  TInt GetAttrId(TInt theId) const;
162  void SetAttrId(TInt theId, TInt theVal);
163 
165  TFamAttr myAttrVal;
167  TInt GetAttrVal(TInt theId) const;
169  void SetAttrVal(TInt theId, TInt theVal);
170 
172  TString myAttrDesc;
174  virtual std::string GetAttrDesc(TInt theId) const = 0;
176  virtual void SetAttrDesc(TInt theId, const std::string& theValue) = 0;
177  };
178 
179 
180  //---------------------------------------------------------------
181  typedef TIntVector TElemNum;
182  typedef SharedPtr<TElemNum> PElemNum;
183 
185  struct MEDWRAPPER_EXPORT TElemInfo: virtual TBase
186  {
187  PMeshInfo myMeshInfo;
188 
189  const PMeshInfo& GetMeshInfo() const { return myMeshInfo;}
190 
191  TInt myNbElem; //<! Number of corresponding mesh entities
192  TInt GetNbElem() const { return myNbElem;}
193 
195  PElemNum myFamNum;
197  TInt GetFamNum(TInt theId) const;
199  void SetFamNum(TInt theId, TInt theVal);
200 
202  EBooleen myIsElemNum;
204  EBooleen IsElemNum() const { return myIsElemNum;}
205 
207  EBooleen myIsFamNum;
209  EBooleen IsFamNum() const { return myIsFamNum;}
210 
211 
213  PElemNum myElemNum;
215  TInt GetElemNum(TInt theId) const;
217  void SetElemNum(TInt theId, TInt theVal);
218 
220  EBooleen myIsElemNames;
222  EBooleen IsElemNames() const { return myIsElemNames;}
223 
225  PString myElemNames;
227  virtual std::string GetElemName(TInt theId) const = 0;
229  virtual void SetElemName(TInt theId, const std::string& theValue) = 0;
230  };
231 
232 
233  //---------------------------------------------------------------
234  typedef TVector<TFloat> TFloatVector;
235  typedef TSlice<TFloat> TFloatVecSlice;
236  typedef TCSlice<TFloat> TCFloatVecSlice;
237 
238  typedef TFloatVector TNodeCoord;
239  typedef SharedPtr<TNodeCoord> PNodeCoord;
240 
241  typedef TFloatVecSlice TCoordSlice;
242  typedef TCFloatVecSlice TCCoordSlice;
243 
245  struct MEDWRAPPER_EXPORT TNodeInfo:
246  virtual TElemInfo,
247  virtual TModeSwitchInfo
248  {
249  PNodeCoord myCoord;
250 
252  TCCoordSlice GetCoordSlice(TInt theId) const;
254  TCoordSlice GetCoordSlice(TInt theId);
255 
256  ERepere mySystem;
257 
258  ERepere GetSystem() const { return mySystem;}
260  void SetSystem(ERepere theSystem) { mySystem = theSystem;}
261 
262  TString myCoordNames;
263 
264  virtual std::string GetCoordName(TInt theId) const = 0;
266  virtual void SetCoordName(TInt theId, const std::string& theValue) = 0;
267 
268  TString myCoordUnits;
269 
270  virtual std::string GetCoordUnit(TInt theId) const = 0;
272  virtual void SetCoordUnit(TInt theId, const std::string& theValue) = 0;
273  };
274 
275 
276  //---------------------------------------------------------------
277  typedef TIntVecSlice TConnSlice;
278  typedef TCIntVecSlice TCConnSlice;
279 
281  struct MEDWRAPPER_EXPORT TCellInfo:
282  virtual TElemInfo,
283  virtual TModeSwitchInfo
284  {
285  EEntiteMaillage myEntity;
286 
287  EEntiteMaillage GetEntity() const { return myEntity;}
288 
289  EGeometrieElement myGeom;
290 
291  EGeometrieElement GetGeom() const { return myGeom;}
292 
293  EConnectivite myConnMode;
294 
295  EConnectivite GetConnMode() const { return myConnMode;}
296 
297  virtual TInt GetConnDim() const = 0;
298 
299  PElemNum myConn;
300 
302  TCConnSlice GetConnSlice(TInt theElemId) const;
304  TConnSlice GetConnSlice(TInt theElemId);
305  };
306 
307  //---------------------------------------------------------------
309  struct MEDWRAPPER_EXPORT TPolygoneInfo:
310  virtual TElemInfo
311  {
313  EEntiteMaillage myEntity; // MED_FACE|MED_MAILLE
315  EEntiteMaillage GetEntity() const { return myEntity;}
316 
318  EGeometrieElement myGeom; // ePOLYGONE
320  EGeometrieElement GetGeom() const { return ePOLYGONE;}
321 
323  EConnectivite myConnMode; // eNOD|eDESC(eDESC not used)
325  EConnectivite GetConnMode() const { return myConnMode;}
326 
327  PElemNum myConn;
328  PElemNum myIndex;
329 
331  TInt GetNbConn(TInt theElemId) const;
332 
334  TCConnSlice GetConnSlice(TInt theElemId) const;
336  TConnSlice GetConnSlice(TInt theElemId);
337  };
338 
339  //---------------------------------------------------------------
341  //
342  // This could be a generic class for any structure element
343  // holding any number of contant and variable attributes
344  // but it's too hard to implement
345  //
346  struct MEDWRAPPER_EXPORT TBallInfo:
347  virtual TCellInfo
348  {
349  TFloatVector myDiameters;
350  };
351 
352  //---------------------------------------------------------------
353  typedef TVector<TCConnSlice> TCConnSliceArr;
354  typedef TVector<TConnSlice> TConnSliceArr;
355 
357  struct MEDWRAPPER_EXPORT TPolyedreInfo:
358  virtual TElemInfo
359  {
361  EEntiteMaillage myEntity; // MED_FACE|MED_MAILLE
363  EEntiteMaillage GetEntity() const { return myEntity;}
364 
366  EGeometrieElement myGeom; // ePOLYEDRE
368  EGeometrieElement GetGeom() const { return ePOLYEDRE;}
369 
371  EConnectivite myConnMode; // eNOD|eDESC(eDESC not used)
373  EConnectivite GetConnMode() const { return myConnMode;}
374 
375  PElemNum myConn;
376  PElemNum myFaces;
377  PElemNum myIndex;
378 
380  TInt GetNbFaces(TInt theElemId) const;
382  TInt GetNbNodes(TInt theElemId) const;
383 
385  TCConnSliceArr GetConnSliceArr(TInt theElemId) const;
387  TConnSliceArr GetConnSliceArr(TInt theElemId);
388  };
389 
390  //---------------------------------------------------------------
392  struct MEDWRAPPER_EXPORT TFieldInfo:
393  virtual TNameInfo
394  {
395  PMeshInfo myMeshInfo;
396 
397  const PMeshInfo& GetMeshInfo() const { return myMeshInfo;}
398 
399  ETypeChamp myType;
400 
401  ETypeChamp GetType() const { return myType;}
402 
403  TInt myNbComp;
404 
405  TInt GetNbComp() const { return myNbComp;}
406 
407  EBooleen myIsLocal;
408 
409  EBooleen GetIsLocal() const { return myIsLocal;}
410 
411  TInt myNbRef;
412 
413  TInt GetNbRef() const { return myNbRef;}
414 
415  TString myCompNames;
416 
417  virtual std::string GetCompName(TInt theId) const = 0;
419  virtual void SetCompName(TInt theId, const std::string& theValue) = 0;
420 
421  TString myUnitNames;
422 
423  virtual std::string GetUnitName(TInt theId) const = 0;
425  virtual void SetUnitName(TInt theId, const std::string& theValue) = 0;
426 
427  };
428 
429 
430  //---------------------------------------------------------------
432  MEDWRAPPER_EXPORT
433  TInt
434  GetDimGaussCoord(EGeometrieElement theGeom);
435 
437  MEDWRAPPER_EXPORT
438  TInt
439  GetNbRefCoord(EGeometrieElement theGeom);
440 
441  typedef TFloatVector TWeight;
442 
444  struct MEDWRAPPER_EXPORT TGaussInfo:
445  virtual TNameInfo,
446  virtual TModeSwitchInfo
447  {
448  typedef boost::tuple<EGeometrieElement,std::string> TKey;
449  typedef boost::tuple<TKey,TInt> TInfo;
450  struct MEDWRAPPER_EXPORT TLess
451  {
452  bool
453  operator()(const TKey& theLeft, const TKey& theRight) const;
454 
455  bool
456  operator()(const TGaussInfo& theLeft, const TGaussInfo& theRight) const;
457  };
458 
460  EGeometrieElement myGeom;
462  EGeometrieElement GetGeom() const { return myGeom;}
463 
465  TNodeCoord myRefCoord;
466 
468  TCCoordSlice GetRefCoordSlice(TInt theId) const;
470  TCoordSlice GetRefCoordSlice(TInt theId);
471 
473  TNodeCoord myGaussCoord;
474 
476  TCCoordSlice GetGaussCoordSlice(TInt theId) const;
478  TCoordSlice GetGaussCoordSlice(TInt theId);
479 
481  TWeight myWeight;
482 
484  TInt GetNbRef() const { return GetNbRefCoord(GetGeom());}
485 
487  TInt GetDim() const { return GetDimGaussCoord(GetGeom());}
488 
490  TInt GetNbGauss() const { return (TInt)(myGaussCoord.size()/GetDim());}
491  };
492 
493 
494  //---------------------------------------------------------------
495  typedef std::map<EGeometrieElement,PGaussInfo> TGeom2Gauss;
496  typedef std::map<EGeometrieElement,TInt> TGeom2NbGauss;
497 
499  struct MEDWRAPPER_EXPORT TTimeStampInfo:
500  virtual TBase
501  {
502  PFieldInfo myFieldInfo;
503 
504  const PFieldInfo& GetFieldInfo() const { return myFieldInfo;}
505 
507  EEntiteMaillage myEntity;
509  EEntiteMaillage GetEntity() const { return myEntity;}
510 
512  TGeom2Size myGeom2Size;
514  const TGeom2Size& GetGeom2Size() const { return myGeom2Size;}
515 
516  TGeom2NbGauss myGeom2NbGauss;
517  TInt GetNbGauss(EGeometrieElement theGeom) const;
518 
519  TInt myNumDt;
520  TInt GetNumDt() const { return myNumDt;}
521 
522  TInt myNumOrd;
523  TInt GetNumOrd() const { return myNumOrd;}
524 
525  TFloat myDt;
526  TFloat GetDt() const { return myDt;}
527 
529  TGeom2Gauss myGeom2Gauss;
531  const TGeom2Gauss& GetGeom2Gauss() const { return myGeom2Gauss;}
532 
533  TString myUnitDt;
534 
535  virtual std::string GetUnitDt() const = 0;
537  virtual void SetUnitDt(const std::string& theValue) = 0;
538  };
539 
540 
541  //---------------------------------------------------------------
543  struct MEDWRAPPER_EXPORT TProfileInfo:
544  virtual TNameInfo
545  {
546  typedef std::string TKey;
547  typedef boost::tuple<TKey,TInt> TInfo;
548 
549  EModeProfil myMode;
550 
551  EModeProfil GetMode() const { return myMode;}
553  void SetMode(EModeProfil theMode) { myMode = theMode;}
554 
555  PElemNum myElemNum;
556 
557  TInt GetElemNum(TInt theId) const;
559  void SetElemNum(TInt theId, TInt theVal);
560 
562  bool IsPresent() const { return GetName() != "";}
563 
565  TInt GetSize() const { return (TInt)myElemNum->size();}
566  };
567 
568 
569  //---------------------------------------------------------------
571  struct MEDWRAPPER_EXPORT TMeshValueBase:
572  virtual TModeSwitchInfo
573  {
574  TInt myNbElem;
575  TInt myNbComp;
576  TInt myNbGauss;
577  TInt myStep;
578 
579  TMeshValueBase();
580 
582  void
583  Allocate(TInt theNbElem,
584  TInt theNbGauss,
585  TInt theNbComp,
586  EModeSwitch theMode = eFULL_INTERLACE);
587 
589  size_t
590  GetSize() const;
591 
593  size_t
594  GetNbVal() const;
595 
597  size_t
598  GetNbGauss() const;
599 
601  size_t
602  GetStep() const;
603 
605  virtual
606  unsigned char*
607  GetValuePtr() = 0;
608  };
609 
610  //---------------------------------------------------------------
612  template<class TValueType>
613  struct TTMeshValue:
614  virtual TMeshValueBase
615  {
616  typedef TValueType TValue;
617  typedef typename TValueType::value_type TElement;
618 
619  typedef TSlice<TElement> TValueSlice;
620  typedef TCSlice<TElement> TCValueSlice;
621 
622  typedef TVector<TCValueSlice> TCValueSliceArr;
623  typedef TVector<TValueSlice> TValueSliceArr;
624 
625  TValue myValue;
626 
628  void
629  Allocate(TInt theNbElem,
630  TInt theNbGauss,
631  TInt theNbComp,
632  EModeSwitch theMode = eFULL_INTERLACE)
633  {
634  TMeshValueBase::Allocate(theNbElem, theNbGauss, theNbComp, theMode);
635  myValue.resize(theNbElem * this->GetStep());
636  }
637 
639  virtual
640  unsigned char*
641  GetValuePtr()
642  {
643  return (unsigned char*)&myValue[0];
644  }
645 
647  virtual
648  TElement*
649  GetPointer()
650  {
651  return &myValue[0];
652  }
653 
655  virtual
656  const TElement*
657  GetPointer() const
658  {
659  return &myValue[0];
660  }
661 
663  TCValueSliceArr
664  GetGaussValueSliceArr(TInt theElemId) const
665  {
666  TCValueSliceArr aValueSliceArr(myNbGauss);
667  if(GetModeSwitch() == eFULL_INTERLACE){
668  TInt anId = theElemId * myStep;
669  for(TInt aGaussId = 0; aGaussId < myNbGauss; aGaussId++){
670  aValueSliceArr[aGaussId] =
671  TCValueSlice(myValue, std::slice(anId, myNbComp, 1));
672  anId += myNbComp;
673  }
674  }
675  else{
676  for(TInt aGaussId = 0; aGaussId < myNbGauss; aGaussId++){
677  aValueSliceArr[aGaussId] =
678  TCValueSlice(myValue, std::slice(theElemId, myNbComp, myStep));
679  }
680  }
681  return aValueSliceArr;
682  }
683 
685  TValueSliceArr
686  GetGaussValueSliceArr(TInt theElemId)
687  {
688  TValueSliceArr aValueSliceArr(myNbGauss);
689  if(GetModeSwitch() == eFULL_INTERLACE){
690  TInt anId = theElemId*myStep;
691  for(TInt aGaussId = 0; aGaussId < myNbGauss; aGaussId++){
692  aValueSliceArr[aGaussId] =
693  TValueSlice(myValue, std::slice(anId, myNbComp, 1));
694  anId += myNbComp;
695  }
696  }
697  else{
698  for(TInt aGaussId = 0; aGaussId < myNbGauss; aGaussId++){
699  aValueSliceArr[aGaussId] =
700  TValueSlice(myValue, std::slice(theElemId, myNbComp, myStep));
701  }
702  }
703  return aValueSliceArr;
704  }
705 
707  TCValueSliceArr
708  GetCompValueSliceArr(TInt theElemId) const
709  {
710  TCValueSliceArr aValueSliceArr(myNbComp);
711  if(GetModeSwitch() == eFULL_INTERLACE){
712  TInt anId = theElemId*myStep;
713  for(TInt aCompId = 0; aCompId < myNbComp; aCompId++){
714  aValueSliceArr[aCompId] =
715  TCValueSlice(myValue, std::slice(anId, myNbGauss, myNbComp));
716  anId += 1;
717  }
718  }
719  else{
720  for(TInt aCompId = 0; aCompId < myNbComp; aCompId++){
721  aValueSliceArr[aCompId] =
722  TCValueSlice(myValue, std::slice(theElemId, myNbGauss, myStep));
723  }
724  }
725  return aValueSliceArr;
726  }
727 
729  TValueSliceArr
730  GetCompValueSliceArr(TInt theElemId)
731  {
732  if(GetModeSwitch() == eFULL_INTERLACE){
733  TValueSliceArr aValueSliceArr(myNbComp);
734  TInt anId = theElemId*myStep;
735  for(TInt aCompId = 0; aCompId < myNbComp; aCompId++){
736  aValueSliceArr[aCompId] =
737  TValueSlice(myValue, std::slice(anId, myNbGauss, myNbComp));
738  anId += 1;
739  }
740  return aValueSliceArr;
741  }
742  else{
743  TValueSliceArr aValueSliceArr(myNbGauss);
744  for(TInt aGaussId = 0; aGaussId < myNbGauss; aGaussId++){
745  aValueSliceArr[aGaussId] =
746  TValueSlice(myValue,std::slice(theElemId, myNbComp, myStep));
747  }
748  return aValueSliceArr;
749  }
750  }
751  };
752 
753  typedef TTMeshValue<TFloatVector> TFloatMeshValue;
754  typedef TTMeshValue<TIntVector> TIntMeshValue;
755 
756  //---------------------------------------------------------------
757  // Backward compatibility declarations
758  typedef TFloatVector TValue;
759  typedef TSlice<TFloat> TValueSlice;
760  typedef TCSlice<TFloat> TCValueSlice;
761 
762  typedef TVector<TCValueSlice> TCValueSliceArr;
763  typedef TVector<TValueSlice> TValueSliceArr;
764 
765  typedef TFloatMeshValue TMeshValue;
766  typedef std::map<EGeometrieElement,TMeshValue> TGeom2Value;
767 
768  //---------------------------------------------------------------
769  typedef std::map<EGeometrieElement,PProfileInfo> TGeom2Profile;
770  typedef std::set<EGeometrieElement> TGeom;
771 
773  struct MEDWRAPPER_EXPORT TTimeStampValueBase:
774  virtual TModeSwitchInfo
775  {
777  PTimeStampInfo myTimeStampInfo;
779  const PTimeStampInfo& GetTimeStampInfo() const { return myTimeStampInfo;}
780 
782  TGeomSet myGeomSet;
783  const TGeomSet& GetGeomSet() const { return myGeomSet;}
784 
786  TGeom2Profile myGeom2Profile;
788  const TGeom2Profile& GetGeom2Profile() const { return myGeom2Profile;}
789 
791  virtual
792  ETypeChamp
793  GetTypeChamp() const = 0;
794 
796  virtual
797  void
798  AllocateValue(EGeometrieElement theGeom,
799  TInt theNbElem,
800  TInt theNbGauss,
801  TInt theNbComp,
802  EModeSwitch theMode = eFULL_INTERLACE) = 0;
803 
804  virtual
805  size_t
806  GetValueSize(EGeometrieElement theGeom) const = 0;
807 
808  virtual
809  size_t
810  GetNbVal(EGeometrieElement theGeom) const = 0;
811 
812  virtual
813  size_t
814  GetNbGauss(EGeometrieElement theGeom) const = 0;
815 
816  virtual
817  unsigned char*
818  GetValuePtr(EGeometrieElement theGeom) = 0;
819  };
820 
821 
822  //---------------------------------------------------------------
824  template<class TMeshValueType>
825  struct TTimeStampValue:
826  virtual TTimeStampValueBase
827  {
828  typedef TMeshValueType TTMeshValue;
829  typedef SharedPtr<TMeshValueType> PTMeshValue;
830  typedef typename TMeshValueType::TElement TElement;
831  typedef std::map<EGeometrieElement, PTMeshValue> TTGeom2Value;
832 
833  ETypeChamp myTypeChamp; //<! Keeps type of the champ
834 
836  virtual
837  ETypeChamp
838  GetTypeChamp() const
839  {
840  return myTypeChamp;
841  }
842 
844  TTGeom2Value myGeom2Value;
845 
846  const TTGeom2Value&
847  GetGeom2Value() const
848  {
849  return myGeom2Value;
850  }
851 
853  const PTMeshValue&
854  GetMeshValuePtr(EGeometrieElement theGeom) const
855  {
856  typename TTGeom2Value::const_iterator anIter = myGeom2Value.find(theGeom);
857  if(anIter == myGeom2Value.end())
858  EXCEPTION(std::runtime_error,"TTimeStampValue::GetMeshValuePtr - myGeom2Value.find(theGeom) fails");
859  return anIter->second;
860  }
861 
863  PTMeshValue&
864  GetMeshValuePtr(EGeometrieElement theGeom)
865  {
866  myGeomSet.insert(theGeom);
867  if(myGeom2Value.find(theGeom) == myGeom2Value.end()){
868  myGeom2Value[theGeom] = PTMeshValue(new TTMeshValue());
869  return myGeom2Value[theGeom];
870  }
871  return myGeom2Value[theGeom];
872  }
873 
875  const TTMeshValue&
876  GetMeshValue(EGeometrieElement theGeom) const
877  {
878  return *(this->GetMeshValuePtr(theGeom));
879  }
880 
882  TTMeshValue&
883  GetMeshValue(EGeometrieElement theGeom)
884  {
885  return *(this->GetMeshValuePtr(theGeom));
886  }
887  };
888 
889 
890  //---------------------------------------------------------------
891  typedef TTimeStampValue<TFloatMeshValue> TFloatTimeStampValue;
892  typedef SharedPtr<TFloatTimeStampValue> PFloatTimeStampValue;
893 
894  PFloatTimeStampValue MEDWRAPPER_EXPORT
895  CastToFloatTimeStampValue(const PTimeStampValueBase& theTimeStampValue);
896 
897  typedef TTimeStampValue<TIntMeshValue> TIntTimeStampValue;
898  typedef SharedPtr<TIntTimeStampValue> PIntTimeStampValue;
899 
900  PIntTimeStampValue MEDWRAPPER_EXPORT
901  CastToIntTimeStampValue(const PTimeStampValueBase& theTimeStampValue);
902 
903 
904  //---------------------------------------------------------------
905  template<class TMeshValueTypeFrom, class TMeshValueTypeTo>
906  void
907  CopyTimeStampValue(SharedPtr<TTimeStampValue<TMeshValueTypeFrom> > theTimeStampValueFrom,
908  SharedPtr<TTimeStampValue<TMeshValueTypeTo> > theTimeStampValueTo)
909  {
910  typedef TTimeStampValue<TMeshValueTypeFrom> TimeStampValueTypeFrom;
911  typedef TTimeStampValue<TMeshValueTypeTo> TimeStampValueTypeTo;
912  typedef typename TMeshValueTypeTo::TElement TElementTo;
913 
914  typename TimeStampValueTypeFrom::TTGeom2Value& aGeom2Value = theTimeStampValueFrom->myGeom2Value;
915  typename TimeStampValueTypeFrom::TTGeom2Value::const_iterator anIter = aGeom2Value.begin();
916  for(; anIter != aGeom2Value.end(); anIter++){
917  const EGeometrieElement& aGeom = anIter->first;
918  const typename TimeStampValueTypeFrom::TTMeshValue& aMeshValue = *anIter->second;
919  typename TimeStampValueTypeTo::TTMeshValue& aMeshValue2 = theTimeStampValueTo->GetMeshValue(aGeom);
920  aMeshValue2.Allocate(aMeshValue.myNbElem,
921  aMeshValue.myNbGauss,
922  aMeshValue.myNbComp,
923  aMeshValue.myModeSwitch);
924  const typename TimeStampValueTypeFrom::TTMeshValue::TValue& aValue = aMeshValue.myValue;
925  typename TimeStampValueTypeTo::TTMeshValue::TValue& aValue2 = aMeshValue2.myValue;
926  TInt aSize = aValue.size();
927  for(TInt anId = 0; anId < aSize; anId++)
928  aValue2[anId] = TElementTo(aValue[anId]);
929  }
930  }
931 
932  template<class TMeshValueType>
933  void
934  CopyTimeStampValue(SharedPtr<TTimeStampValue<TMeshValueType> > theTimeStampValueFrom,
935  SharedPtr<TTimeStampValue<TMeshValueType> > theTimeStampValueTo)
936  {
937  typedef TTimeStampValue<TMeshValueType> TimeStampValueType;
938  typename TimeStampValueType::TTGeom2Value& aGeom2Value = theTimeStampValueFrom->myGeom2Value;
939  typename TimeStampValueType::TTGeom2Value::const_iterator anIter = aGeom2Value.begin();
940  for(; anIter != aGeom2Value.end(); anIter++){
941  const EGeometrieElement& aGeom = anIter->first;
942  const typename TimeStampValueType::TTMeshValue& aMeshValue = *anIter->second;
943  typename TimeStampValueType::TTMeshValue& aMeshValue2 = theTimeStampValueTo->GetMeshValue(aGeom);
944  aMeshValue2 = aMeshValue;
945  }
946  }
947 
948  //---------------------------------------------------------------
949  inline
950  void
951  CopyTimeStampValueBase(const PTimeStampValueBase& theValueFrom,
952  const PTimeStampValueBase& theValueTo)
953  {
954  if(theValueFrom->GetTypeChamp() == theValueTo->GetTypeChamp()){
955  if(theValueFrom->GetTypeChamp() == eFLOAT64)
956  CopyTimeStampValue<TFloatMeshValue>(theValueFrom, theValueTo);
957  else if(theValueFrom->GetTypeChamp() == eINT)
958  CopyTimeStampValue<TIntMeshValue>(theValueFrom, theValueTo);
959  }else{
960  if(theValueFrom->GetTypeChamp() == eFLOAT64 && theValueTo->GetTypeChamp() == eINT)
961  CopyTimeStampValue<TFloatMeshValue, TIntMeshValue>(theValueFrom, theValueTo);
962  else if(theValueFrom->GetTypeChamp() == eINT && theValueTo->GetTypeChamp() == eFLOAT64)
963  CopyTimeStampValue<TIntMeshValue, TFloatMeshValue>(theValueFrom, theValueTo);
964  }
965  }
966 
967 
968  //---------------------------------------------------------------
969  // Backward compatibility declarations
970  typedef TFloatTimeStampValue TTimeStampVal;
971  typedef PFloatTimeStampValue PTimeStampVal;
972 
973  //---------------------------------------------------------------
974  typedef std::map<TInt,TFloatVector> TIndexes;
975  typedef std::map<TInt,TString> TNames;
976 
978  struct MEDWRAPPER_EXPORT TGrilleInfo:
979  virtual TModeSwitchInfo
980  {
981 
982  PMeshInfo myMeshInfo;
983  const PMeshInfo& GetMeshInfo() const { return myMeshInfo;}
984 
985  TNodeCoord myCoord;
986 
987  const TNodeCoord& GetNodeCoord() const;
988  TNodeCoord& GetNodeCoord();
990  TNodeCoord GetCoord(TInt theId);
992  TIntVector GetConn(TInt theId, const bool isSub=false);
993 
994  EGrilleType myGrilleType;
995 
996  const EGrilleType& GetGrilleType() const;
998  EGrilleType GetGrilleType();
1000  void SetGrilleType(EGrilleType theGrilleType);
1001 
1002 
1003 
1004  TString myCoordNames;
1005 
1006  virtual std::string GetCoordName(TInt theId) const = 0 ;
1008  virtual void SetCoordName(TInt theId, const std::string& theValue) = 0;
1009 
1010  TString myCoordUnits;
1011 
1012  virtual std::string GetCoordUnit(TInt theId) const = 0;
1014  virtual void SetCoordUnit(TInt theId, const std::string& theValue) = 0;
1015 
1016 
1018  TIndexes myIndixes;
1020  const TIndexes& GetMapOfIndexes() const ;
1022  TIndexes& GetMapOfIndexes();
1024  const TFloatVector& GetIndexes(TInt theAxisNumber) const;
1026  TFloatVector& GetIndexes(TInt theAxisNumber);
1028  TInt GetNbIndexes(TInt theAxisNumber);
1029 
1030  TInt GetNbNodes();
1031  TInt GetNbCells();
1032  TInt GetNbSubCells();
1033  EGeometrieElement GetGeom();
1034  EGeometrieElement GetSubGeom();
1035  EEntiteMaillage GetEntity();
1036  EEntiteMaillage GetSubEntity();
1037 
1041  TIntVector myGrilleStructure;
1043  const TIntVector& GetGrilleStructure() const;
1045  TIntVector GetGrilleStructure();
1047  void SetGrilleStructure(TInt theAxis,TInt theNb);
1048 
1052  TElemNum myFamNum;
1054  TInt GetFamNum(TInt theId) const;
1056  void SetFamNum(TInt theId, TInt theVal);
1057 
1061  TElemNum myFamSubNum;
1063  TInt GetFamSubNum(TInt theId) const;
1065  void SetFamSubNum(TInt theId, TInt theVal);
1066 
1070  TElemNum myFamNumNode;
1072  TInt GetFamNumNode(TInt theId) const;
1074  void SetFamNumNode(TInt theId, TInt theVal);
1075 
1076  };
1077 
1078 
1079 }
1080 
1081 #endif