]> SALOME platform Git repositories - tools/medcoupling.git/blob - src/MEDCoupling/MEDCouplingMultiFields.cxx
Salome HOME
Little refactoring of progeny mechanism to avoid if.
[tools/medcoupling.git] / src / MEDCoupling / MEDCouplingMultiFields.cxx
1 // Copyright (C) 2007-2014  CEA/DEN, EDF R&D
2 //
3 // This library is free software; you can redistribute it and/or
4 // modify it under the terms of the GNU Lesser General Public
5 // License as published by the Free Software Foundation; either
6 // version 2.1 of the License, or (at your option) any later version.
7 //
8 // This library is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11 // Lesser General Public License for more details.
12 //
13 // You should have received a copy of the GNU Lesser General Public
14 // License along with this library; if not, write to the Free Software
15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
16 //
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
18 //
19 // Author : Anthony Geay (CEA/DEN)
20
21 #include "MEDCouplingMultiFields.hxx"
22 #include "MEDCouplingFieldTemplate.hxx"
23 #include "MEDCouplingFieldDouble.hxx"
24 #include "MEDCouplingMesh.hxx"
25 #include "MEDCouplingAutoRefCountObjectPtr.hxx"
26
27 #include <sstream>
28 #include <algorithm>
29
30 using namespace ParaMEDMEM;
31
32 MEDCouplingMultiFields *MEDCouplingMultiFields::New(const std::vector<MEDCouplingFieldDouble *>& fs)
33 {
34   return new MEDCouplingMultiFields(fs);
35 }
36
37 MEDCouplingMultiFields *MEDCouplingMultiFields::New()
38 {
39   return new MEDCouplingMultiFields;
40 }
41
42 MEDCouplingMultiFields *MEDCouplingMultiFields::deepCpy() const
43 {
44   return new MEDCouplingMultiFields(*this);
45 }
46
47 bool MEDCouplingMultiFields::isEqual(const MEDCouplingMultiFields *other, double meshPrec, double valsPrec) const
48 {
49   std::size_t sz=_fs.size();
50   if(sz!=other->_fs.size())
51     return false;
52   for(std::size_t i=0;i<sz;i++)
53     {
54       const MEDCouplingFieldDouble *f1=_fs[i];
55       const MEDCouplingFieldDouble *f2=other->_fs[i];
56       if(f1!=f2)
57         {
58           if(f1==0 || f2==0)
59             return false;
60           if(!_fs[i]->isEqual(other->_fs[i],meshPrec,valsPrec))
61             return false;
62         }
63     }
64   std::vector<int> refs1,refs2;
65   std::vector<MEDCouplingMesh *> ms1=getDifferentMeshes(refs1);
66   std::vector<MEDCouplingMesh *> ms2=other->getDifferentMeshes(refs2);
67   if(ms1.size()!=ms2.size())
68     return false;
69   if(refs1!=refs2)
70     return false;
71   std::vector< std::vector<int> > refs3,refs4;
72   std::vector<DataArrayDouble *> das1=getDifferentArrays(refs3);
73   std::vector<DataArrayDouble *> das2=getDifferentArrays(refs4);
74   if(das1.size()!=das2.size())
75     return false;
76   if(refs3!=refs4)
77     return false;
78   return true;
79 }
80
81 std::string MEDCouplingMultiFields::getName() const
82 {
83   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> >::const_iterator it=_fs.begin();
84   for(;it!=_fs.end();it++)
85     if((const MEDCouplingFieldDouble *)(*it))
86       return (*it)->getName();
87   return std::string();
88 }
89
90 std::string MEDCouplingMultiFields::getDescription() const
91 {
92   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> >::const_iterator it=_fs.begin();
93   for(;it!=_fs.end();it++)
94     if((const MEDCouplingFieldDouble *)(*it))
95       return (*it)->getDescription();
96   return std::string();
97 }
98
99 std::string MEDCouplingMultiFields::getTimeUnit() const
100 {
101   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> >::const_iterator it=_fs.begin();
102   for(;it!=_fs.end();it++)
103     if((const MEDCouplingFieldDouble *)(*it))
104       return (*it)->getTimeUnit();
105   return std::string();
106 }
107
108 double MEDCouplingMultiFields::getTimeResolution() const
109 {
110   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> >::const_iterator it=_fs.begin();
111   for(;it!=_fs.end();it++)
112     if((const MEDCouplingFieldDouble *)(*it))
113       return (*it)->getTimeTolerance();
114   throw INTERP_KERNEL::Exception("MEDCouplingMultiFields::getTimeResolution : no not null field !");
115 }
116
117 std::string MEDCouplingMultiFields::simpleRepr() const
118 {
119   std::ostringstream ret;
120   ret << "MEDCouplingMultiFields with name : \"" << getName() << "\"\n";
121   ret << "Description of MEDCouplingMultiFields is : \"" << getDescription() << "\"\n";
122   ret << "Number of discretization : " << _fs.size() << "\n";
123   ret << "Number of different meshes : ";
124   std::vector<MEDCouplingMesh *> ms;
125   std::vector<int> refms;
126   try
127   {
128       ms=getDifferentMeshes(refms);
129       ret << ms.size() << "\n";
130   }
131   catch(INTERP_KERNEL::Exception& /*e*/)
132   { ret << "Current instance is INVALID !\n"; }
133   return ret.str();
134 }
135
136 std::string MEDCouplingMultiFields::advancedRepr() const
137 {
138   return simpleRepr();
139 }
140
141 bool MEDCouplingMultiFields::isEqualWithoutConsideringStr(const MEDCouplingMultiFields *other, double meshPrec, double valsPrec) const
142 {
143   std::size_t sz=_fs.size();
144   if(sz!=other->_fs.size())
145     return false;
146   for(std::size_t i=0;i<sz;i++)
147     if(!_fs[i]->isEqualWithoutConsideringStr(other->_fs[i],meshPrec,valsPrec))
148       return false;
149   return true;
150 }
151
152 const MEDCouplingFieldDouble *MEDCouplingMultiFields::getFieldWithId(int id) const
153 {
154   if(id>=(int)_fs.size() || id < 0)
155     throw INTERP_KERNEL::Exception("MEDCouplingMultiFields::getFieldWithId : invalid id outside boundaries !");
156   return _fs[id];
157 }
158
159 std::vector<const MEDCouplingFieldDouble *> MEDCouplingMultiFields::getFields() const
160 {
161   std::vector<const MEDCouplingFieldDouble *> ret(_fs.size());
162   std::copy(_fs.begin(),_fs.end(),ret.begin());
163   return ret;
164 }
165
166 int MEDCouplingMultiFields::getNumberOfFields() const
167 {
168   return (int)_fs.size();
169 }
170
171 const MEDCouplingFieldDouble *MEDCouplingMultiFields::getFieldAtPos(int id) const
172 {
173   if(id<0 || id>=(int)_fs.size())
174     {
175       std::ostringstream oss; oss << "MEDCouplingMultiFields::getFieldAtPos : Invalid given pos : should be >=0 and < " << _fs.size() << " !";
176       throw INTERP_KERNEL::Exception(oss.str().c_str());
177     }
178   return _fs[id];
179 }
180
181 void MEDCouplingMultiFields::updateTime() const
182 {
183   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> >::const_iterator it=_fs.begin();
184   for(;it!=_fs.end();it++)
185     if((const MEDCouplingFieldDouble *)(*it))
186       (*it)->updateTime();
187   it=_fs.begin();
188   for(;it!=_fs.end();it++)
189     if((const MEDCouplingFieldDouble *)(*it))
190       updateTimeWith(*(*it));
191 }
192
193 std::size_t MEDCouplingMultiFields::getHeapMemorySizeWithoutChildren() const
194 {
195   return 0;
196 }
197
198 std::vector<const BigMemoryObject *> MEDCouplingMultiFields::getDirectChildrenWithNull() const
199 {
200   std::vector<const BigMemoryObject *> ret;
201   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> >::const_iterator it=_fs.begin();it!=_fs.end();it++)
202     ret.push_back((const MEDCouplingFieldDouble *)*it);
203   return ret;
204 }
205
206 std::vector<MEDCouplingMesh *> MEDCouplingMultiFields::getMeshes() const
207 {
208   std::vector<MEDCouplingMesh *> ms;
209   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> >::const_iterator it=_fs.begin();it!=_fs.end();it++)
210     {
211       const MEDCouplingMesh *m=0;
212       if((const MEDCouplingFieldDouble *)(*it))
213         m=(*it)->getMesh();
214       ms.push_back(const_cast<MEDCouplingMesh *>(m));
215     }
216   return ms;
217 }
218
219 std::vector<MEDCouplingMesh *> MEDCouplingMultiFields::getDifferentMeshes(std::vector<int>& refs) const
220 {
221   refs.resize(_fs.size());
222   std::vector<MEDCouplingMesh *> ms;
223   int id=0;
224   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> >::const_iterator it=_fs.begin();it!=_fs.end();it++,id++)
225     {
226       const MEDCouplingMesh *m=0;
227       if((const MEDCouplingFieldDouble *)(*it))
228         m=(*it)->getMesh();
229       if(m)
230         {
231           std::vector<MEDCouplingMesh *>::iterator it2=std::find(ms.begin(),ms.end(),m);
232           if(it2==ms.end())
233             {
234               ms.push_back(const_cast<MEDCouplingMesh *>(m));
235               refs[id]=(int)ms.size()-1;
236             }
237           else
238             refs[id]=(int)std::distance(ms.begin(),it2);
239         }
240       else
241         refs[id]=-1;
242     }
243   return ms;
244 }
245
246 std::vector<DataArrayDouble *> MEDCouplingMultiFields::getArrays() const
247 {
248   std::vector<DataArrayDouble *> tmp;
249   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> >::const_iterator it=_fs.begin();it!=_fs.end();it++)
250     {
251       std::vector<DataArrayDouble *> tmp2=(*it)->getArrays();
252       tmp.insert(tmp.end(),tmp2.begin(),tmp2.end());
253     }
254   return tmp;
255 }
256
257 std::vector<DataArrayDouble *> MEDCouplingMultiFields::getDifferentArrays(std::vector< std::vector<int> >& refs) const
258 {
259   refs.resize(_fs.size());
260   int id=0;
261   std::vector<DataArrayDouble *> ret;
262   for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> >::const_iterator it=_fs.begin();it!=_fs.end();it++,id++)
263     {
264       std::vector<DataArrayDouble *> tmp2;
265       if((const MEDCouplingFieldDouble *)(*it))
266         {
267           tmp2=(*it)->getArrays();
268           refs[id].resize(tmp2.size());
269         }
270       else
271         refs[id].clear();
272       int id2=0;
273       for(std::vector<DataArrayDouble *>::const_iterator it2=tmp2.begin();it2!=tmp2.end();it2++,id2++)
274         {
275           if(*it2)
276             {
277               std::vector<DataArrayDouble *>::iterator it3=std::find(ret.begin(),ret.end(),*it2);
278               if(it3==ret.end())
279                 {
280                   ret.push_back(*it2);
281                   refs[id][id2]=(int)ret.size()-1;
282                 }
283               else
284                 refs[id][id2]=(int)std::distance(ret.begin(),it3);
285             }
286           else
287             refs[id][id2]=-1;
288         }
289     }
290   return ret;
291 }
292
293 void MEDCouplingMultiFields::checkCoherency() const
294 {
295   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> >::const_iterator it=_fs.begin();
296   for(;it!=_fs.end();it++)
297     {
298       if((const MEDCouplingFieldDouble *)(*it)==0)
299         throw INTERP_KERNEL::Exception("MEDCouplingMultiFields::checkCoherency : There is an empty Field in array...");
300       (*it)->checkCoherency();
301     }
302 }
303
304 MEDCouplingMultiFields::MEDCouplingMultiFields(const std::vector<MEDCouplingFieldDouble *>& fs):_fs(fs.size())
305 {
306   int id=0;
307   for(std::vector< MEDCouplingFieldDouble * >::const_iterator it=fs.begin();it!=fs.end();it++,id++)
308     {
309       if(*it)
310         (*it)->incrRef();
311       else
312         throw INTERP_KERNEL::Exception("MEDCouplingMultiFields constructor : empty field found in vector !");
313       (*it)->checkCoherency();
314       _fs[id]=*it;
315     }
316 }
317
318
319 /*!
320  * Performs deepCpy.
321  */
322 MEDCouplingMultiFields::MEDCouplingMultiFields(const MEDCouplingMultiFields& other):RefCountObject(other)
323 {
324   std::size_t sz=other._fs.size();
325   _fs.resize(sz);
326   std::vector<int> refs;
327   std::vector< std::vector<int> > refs2;
328   std::vector<MEDCouplingMesh *> ms=other.getDifferentMeshes(refs);
329   std::size_t msLgh=ms.size();
330   std::vector< MEDCouplingAutoRefCountObjectPtr<MEDCouplingMesh> > ms2(msLgh);
331   for(std::size_t i=0;i<msLgh;i++)
332     ms2[i]=ms[i]->deepCpy();
333   std::vector<DataArrayDouble *> das=other.getDifferentArrays(refs2);
334   std::size_t dasLgth=das.size();
335   std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> > das2(dasLgth);
336   for(std::size_t i=0;i<dasLgth;i++)
337     das2[i]=das[i]->deepCpy();
338   for(std::size_t i=0;i<sz;i++)
339     {
340       if((const MEDCouplingFieldDouble *)other._fs[i])
341         {
342           MEDCouplingFieldTemplate *tmp=MEDCouplingFieldTemplate::New(*other._fs[i]);
343           _fs[i]=MEDCouplingFieldDouble::New(*tmp,other._fs[i]->getTimeDiscretization());
344           tmp->decrRef();
345           if(refs[i]!=-1)
346             _fs[i]->setMesh(ms2[refs[i]]);
347           std::size_t nbOfArr=refs2[i].size();
348           std::vector<DataArrayDouble *> tmp2(nbOfArr);
349           for(std::size_t j=0;j<nbOfArr;j++)
350             {
351               if(refs2[i][j]!=-1)
352                 tmp2[j]=das2[refs2[i][j]];
353               else
354                 tmp2[j]=0;
355             }
356           _fs[i]->setArrays(tmp2);
357           std::vector<int> tinyInfo;
358           std::vector<double> tinyInfo2;
359           other._fs[i]->getTimeDiscretizationUnderGround()->getTinySerializationIntInformation2(tinyInfo);
360           other._fs[i]->getTimeDiscretizationUnderGround()->getTinySerializationDbleInformation2(tinyInfo2);
361           _fs[i]->getTimeDiscretizationUnderGround()->finishUnserialization2(tinyInfo,tinyInfo2);
362         }
363     }
364 }
365
366 MEDCouplingMultiFields::MEDCouplingMultiFields()
367 {
368 }
369
370 void MEDCouplingMultiFields::getTinySerializationInformation(std::vector<int>& tinyInfo, std::vector<double>& tinyInfo2, int& nbOfDiffMeshes, int& nbOfDiffArr) const
371 {
372   std::vector<int> refs;
373   std::vector<MEDCouplingMesh *> ms=getDifferentMeshes(refs);
374   nbOfDiffMeshes=(int)ms.size();
375   std::vector< std::vector<int> > refs2;
376   std::vector<DataArrayDouble *> fs=getDifferentArrays(refs2);
377   nbOfDiffArr=(int)fs.size();
378   //
379   std::size_t sz=refs.size();//==_fs.size()
380   int sz2=0;
381   for(std::size_t i=0;i<sz;i++)
382     sz2+=(int)refs2[i].size();
383   //
384   tinyInfo2.clear();
385   std::vector<int> doubleDaInd(sz);
386   std::vector<int> timeDiscrInt;
387   tinyInfo.resize(sz2+5*sz+3);
388   tinyInfo[0]=(int)sz;
389   tinyInfo[1]=sz2;
390   for(std::size_t i=0;i<sz;i++)
391     {
392       std::vector<double> tmp;
393       std::vector<int> tmp2;
394       _fs[i]->getTimeDiscretizationUnderGround()->getTinySerializationDbleInformation2(tmp);
395       _fs[i]->getTimeDiscretizationUnderGround()->getTinySerializationIntInformation2(tmp2);
396       tinyInfo[3*sz+3+i]=(int)tmp.size();
397       tinyInfo[4*sz+3+i]=(int)tmp2.size();
398       tinyInfo2.insert(tinyInfo2.end(),tmp.begin(),tmp.end());
399       timeDiscrInt.insert(timeDiscrInt.end(),tmp2.begin(),tmp2.end());
400     }
401   int sz3=(int)timeDiscrInt.size();
402   tinyInfo[2]=sz3;
403   //
404   for(std::size_t i=0;i<sz;i++)
405     tinyInfo[i+3]=refs[i];
406   for(std::size_t i=0;i<sz;i++)
407     tinyInfo[i+sz+3]=(int)refs2[i].size();
408   for(std::size_t i=0;i<sz;i++)
409     tinyInfo[i+2*sz+3]=(int)_fs[i]->getTimeDiscretization();
410   int k=0;
411   for(std::size_t i=0;i<sz;i++)
412     for(std::vector<int>::const_iterator it=refs2[i].begin();it!=refs2[i].end();it++,k++)
413       tinyInfo[5*sz+k+3]=*it;
414   tinyInfo.insert(tinyInfo.end(),timeDiscrInt.begin(),timeDiscrInt.end());//tinyInfo has lgth==sz3+sz2+5*sz+3
415 }
416
417 void MEDCouplingMultiFields::finishUnserialization(const std::vector<int>& tinyInfoI, const std::vector<double>& tinyInfoD,
418                                                    const std::vector<MEDCouplingFieldTemplate *>& ft, const std::vector<MEDCouplingMesh *>& ms,
419                                                    const std::vector<DataArrayDouble *>& das)
420 {
421   int sz=tinyInfoI[0];
422   _fs.resize(sz);
423   int sz2=tinyInfoI[1];
424   // dealing with ft with no mesh set.
425   for(int i=0;i<sz;i++)
426     {
427       int meshId=tinyInfoI[3+i];
428       if(meshId!=-1)
429         ft[i]->setMesh(ms[meshId]);
430     }
431   // dealing with fieldtemplate->fielddouble
432   int k=0;
433   int offI=0;
434   int offD=0;
435   for(int i=0;i<sz;i++)
436     {
437       _fs[i]=MEDCouplingFieldDouble::New(*ft[i],(TypeOfTimeDiscretization)tinyInfoI[2*sz+3+i]);
438       int sz3=tinyInfoI[sz+i+3];
439       std::vector<DataArrayDouble *> tmp(sz3);
440       for(int j=0;j<sz3;j++,k++)
441         {
442           int daId=tinyInfoI[5*sz+k+3];
443           if(daId!=-1)
444             tmp[j]=das[daId];
445           else
446             tmp[j]=0;
447         }
448       _fs[i]->setArrays(tmp);
449       // time discr tiny info
450       int lgthI=tinyInfoI[4*sz+3+i];
451       int lgthD=tinyInfoI[3*sz+3+i];
452       //
453       std::vector<int> tdInfoI(tinyInfoI.begin()+sz2+5*sz+3+offI,tinyInfoI.begin()+sz2+5*sz+3+offI+lgthI);
454       std::vector<double> tdInfoD(tinyInfoD.begin()+offD,tinyInfoD.begin()+offD+lgthD);
455       _fs[i]->getTimeDiscretizationUnderGround()->finishUnserialization2(tdInfoI,tdInfoD);
456       //
457       offI+=lgthI;
458       offD+=lgthD;
459     }
460 }