1 // Copyright (C) 2010-2014 CEA/DEN, EDF R&D
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.
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.
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
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
19 // Author : Anthony Geay
21 #include "MEDTimeReq.hxx"
22 #include "MEDUtilities.hxx"
24 #include "MEDFileFieldRepresentationTree.hxx"
25 #include "MEDCouplingFieldDiscretization.hxx"
26 #include "MEDCouplingFieldDouble.hxx"
27 #include "InterpKernelGaussCoords.hxx"
28 #include "MEDFileData.hxx"
29 #include "SauvReader.hxx"
31 #ifdef MEDREADER_USE_MPI
32 #include "ParaMEDFileMesh.hxx"
35 #include "vtkXMLUnstructuredGridWriter.h"//
37 #include "vtkUnstructuredGrid.h"
38 #include "vtkRectilinearGrid.h"
39 #include "vtkStructuredGrid.h"
40 #include "vtkUnsignedCharArray.h"
41 #include "vtkQuadratureSchemeDefinition.h"
42 #include "vtkInformationQuadratureSchemeDefinitionVectorKey.h"
43 #include "vtkInformationIntegerKey.h"
44 #include "vtkInformation.h"
45 #include "vtkIdTypeArray.h"
46 #include "vtkDoubleArray.h"
47 #include "vtkIntArray.h"
48 #include "vtkCellArray.h"
49 #include "vtkPointData.h"
50 #include "vtkFieldData.h"
51 #include "vtkCellData.h"
53 #include "vtksys/stl/string"
54 #include "vtksys/ios/fstream"
55 #include "vtksys/stl/algorithm"
56 #include "vtkMutableDirectedGraph.h"
58 using namespace ParaMEDMEM;
60 const char MEDFileFieldRepresentationLeavesArrays::ZE_SEP[]="@@][@@";
62 const char MEDFileFieldRepresentationLeavesArrays::TS_STR[]="TS";
64 const char MEDFileFieldRepresentationLeavesArrays::COM_SUP_STR[]="ComSup";
66 const char MEDFileFieldRepresentationLeavesArrays::FAMILY_ID_CELL_NAME[]="FamilyIdCell";
68 const char MEDFileFieldRepresentationLeavesArrays::NUM_ID_CELL_NAME[]="NumIdCell";
70 const char MEDFileFieldRepresentationLeavesArrays::FAMILY_ID_NODE_NAME[]="FamilyIdNode";
72 const char MEDFileFieldRepresentationLeavesArrays::NUM_ID_NODE_NAME[]="NumIdNode";
74 const char MEDFileFieldRepresentationTree::ROOT_OF_GRPS_IN_TREE[]="zeGrps";
76 const char MEDFileFieldRepresentationTree::ROOT_OF_FAM_IDS_IN_TREE[]="zeFamIds";
78 const char MEDFileFieldRepresentationTree::COMPO_STR_TO_LOCATE_MESH_DA[]="-@?|*_";
80 vtkIdTypeArray *ELGACmp::findOrCreate(const ParaMEDMEM::MEDFileFieldGlobsReal *globs, const std::vector<std::string>& locsReallyUsed, vtkDoubleArray *vtkd, vtkDataSet *ds, bool& isNew) const
82 vtkIdTypeArray *try0(isExisting(locsReallyUsed,vtkd));
91 return createNew(globs,locsReallyUsed,vtkd,ds);
95 vtkIdTypeArray *ELGACmp::isExisting(const std::vector<std::string>& locsReallyUsed, vtkDoubleArray *vtkd) const
97 std::vector< std::vector<std::string> >::iterator it(std::find(_loc_names.begin(),_loc_names.end(),locsReallyUsed));
98 if(it==_loc_names.end())
100 std::size_t pos(std::distance(_loc_names.begin(),it));
101 vtkIdTypeArray *ret(_elgas[pos]);
102 vtkInformationQuadratureSchemeDefinitionVectorKey *key(vtkQuadratureSchemeDefinition::DICTIONARY());
103 for(std::vector<std::pair< vtkQuadratureSchemeDefinition *, unsigned char > >::const_iterator it=_defs[pos].begin();it!=_defs[pos].end();it++)
105 key->Set(vtkd->GetInformation(),(*it).first,(*it).second);
107 vtkd->GetInformation()->Set(vtkQuadratureSchemeDefinition::QUADRATURE_OFFSET_ARRAY_NAME(),ret->GetName());
111 vtkIdTypeArray *ELGACmp::createNew(const ParaMEDMEM::MEDFileFieldGlobsReal *globs, const std::vector<std::string>& locsReallyUsed, vtkDoubleArray *vtkd, vtkDataSet *ds) const
113 static const int VTK_DATA_ARRAY_DELETE=vtkDataArrayTemplate<double>::VTK_DATA_ARRAY_DELETE;
114 std::vector< std::vector<std::string> > locNames(_loc_names);
115 std::vector<vtkIdTypeArray *> elgas(_elgas);
116 std::vector< std::pair< vtkQuadratureSchemeDefinition *, unsigned char > > defs;
118 std::vector< std::vector<std::string> >::const_iterator it(std::find(locNames.begin(),locNames.end(),locsReallyUsed));
119 if(it!=locNames.end())
120 throw INTERP_KERNEL::Exception("ELGACmp::createNew : Method is expected to be called after isExisting call ! Entry already exists !");
121 locNames.push_back(locsReallyUsed);
122 vtkIdTypeArray *elga(vtkIdTypeArray::New());
123 elga->SetNumberOfComponents(1);
124 vtkInformationQuadratureSchemeDefinitionVectorKey *key(vtkQuadratureSchemeDefinition::DICTIONARY());
125 std::map<unsigned char,int> m;
126 for(std::vector<std::string>::const_iterator it=locsReallyUsed.begin();it!=locsReallyUsed.end();it++)
128 vtkQuadratureSchemeDefinition *def(vtkQuadratureSchemeDefinition::New());
129 const MEDFileFieldLoc& loc(globs->getLocalization((*it).c_str()));
130 INTERP_KERNEL::NormalizedCellType ct(loc.getGeoType());
131 const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel(ct));
132 int nbGaussPt(loc.getNbOfGaussPtPerCell()),nbPtsPerCell((int)cm.getNumberOfNodes()),dimLoc(loc.getDimension());
133 // WARNING : these 2 lines are a workaround, due to users that write a ref element with dimension not equal to dimension of the geometric element.
134 std::vector<double> gsCoods2(INTERP_KERNEL::GaussInfo::NormalizeCoordinatesIfNecessary(ct,dimLoc,loc.getGaussCoords()));
135 std::vector<double> refCoods2(INTERP_KERNEL::GaussInfo::NormalizeCoordinatesIfNecessary(ct,dimLoc,loc.getRefCoords()));
136 double *shape(new double[nbPtsPerCell*nbGaussPt]);
137 INTERP_KERNEL::GaussInfo calculator(ct,gsCoods2,nbGaussPt,refCoods2,nbPtsPerCell);
138 calculator.initLocalInfo();
139 const std::vector<double>& wgths(loc.getGaussWeights());
140 for(int i=0;i<nbGaussPt;i++)
142 const double *pt0(calculator.getFunctionValues(i));
143 if(ct!=INTERP_KERNEL::NORM_HEXA27)
144 std::copy(pt0,pt0+nbPtsPerCell,shape+nbPtsPerCell*i);
147 for(int j=0;j<27;j++)
148 shape[nbPtsPerCell*i+j]=pt0[MEDMeshMultiLev::HEXA27_PERM_ARRAY[j]];
151 unsigned char vtkType(MEDMeshMultiLev::PARAMEDMEM_2_VTKTYPE[ct]);
152 m[vtkType]=nbGaussPt;
153 def->Initialize(vtkType,nbPtsPerCell,nbGaussPt,shape,const_cast<double *>(&wgths[0]));
155 key->Set(elga->GetInformation(),def,vtkType);
156 key->Set(vtkd->GetInformation(),def,vtkType);
157 defs.push_back(std::pair< vtkQuadratureSchemeDefinition *, unsigned char >(def,vtkType));
160 vtkIdType ncell(ds->GetNumberOfCells());
161 int *pt(new int[ncell]),offset(0);
162 for(vtkIdType cellId=0;cellId<ncell;cellId++)
164 vtkCell *cell(ds->GetCell(cellId));
165 int delta(m[cell->GetCellType()]);
169 elga->GetInformation()->Set(MEDUtilities::ELGA(),1);
170 elga->SetArray(pt,ncell,0,VTK_DATA_ARRAY_DELETE);
171 std::ostringstream oss; oss << "ELGA" << "@" << _loc_names.size();
172 std::string ossStr(oss.str());
173 elga->SetName(ossStr.c_str());
174 elga->GetInformation()->Set(vtkAbstractArray::GUI_HIDE(),1);
175 vtkd->GetInformation()->Set(vtkQuadratureSchemeDefinition::QUADRATURE_OFFSET_ARRAY_NAME(),elga->GetName());
176 elgas.push_back(elga);
180 _defs.push_back(defs);
183 void ELGACmp::appendELGAIfAny(vtkDataSet *ds) const
185 for(std::vector<vtkIdTypeArray *>::const_iterator it=_elgas.begin();it!=_elgas.end();it++)
186 ds->GetCellData()->AddArray(*it);
191 for(std::vector<vtkIdTypeArray *>::const_iterator it=_elgas.begin();it!=_elgas.end();it++)
193 for(std::vector< std::vector< std::pair< vtkQuadratureSchemeDefinition *, unsigned char > > >::const_iterator it0=_defs.begin();it0!=_defs.end();it0++)
194 for(std::vector< std::pair< vtkQuadratureSchemeDefinition *, unsigned char > >::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++)
195 (*it1).first->Delete();
200 MEDFileFieldRepresentationLeavesArrays::MEDFileFieldRepresentationLeavesArrays():_id(-1)
204 MEDFileFieldRepresentationLeavesArrays::MEDFileFieldRepresentationLeavesArrays(const ParaMEDMEM::MEDCouplingAutoRefCountObjectPtr<ParaMEDMEM::MEDFileAnyTypeFieldMultiTS>& arr):ParaMEDMEM::MEDCouplingAutoRefCountObjectPtr<ParaMEDMEM::MEDFileAnyTypeFieldMultiTS>(arr),_activated(false),_id(-1)
206 std::vector< std::vector<ParaMEDMEM::TypeOfField> > typs((operator->())->getTypesOfFieldAvailable());
208 throw INTERP_KERNEL::Exception("There is a big internal problem in MEDLoader ! The field time spitting has failed ! A CRASH will occur soon !");
209 if(typs[0].size()!=1)
210 throw INTERP_KERNEL::Exception("There is a big internal problem in MEDLoader ! The field spitting by spatial discretization has failed ! A CRASH will occur soon !");
211 ParaMEDMEM::MEDCouplingAutoRefCountObjectPtr<ParaMEDMEM::MEDCouplingFieldDiscretization> fd(MEDCouplingFieldDiscretization::New(typs[0][0]));
212 std::ostringstream oss2; oss2 << (operator->())->getName() << ZE_SEP << fd->getRepr();
216 MEDFileFieldRepresentationLeavesArrays& MEDFileFieldRepresentationLeavesArrays::operator=(const MEDFileFieldRepresentationLeavesArrays& other)
218 ParaMEDMEM::MEDCouplingAutoRefCountObjectPtr<ParaMEDMEM::MEDFileAnyTypeFieldMultiTS>::operator=(other);
221 _ze_name=other._ze_name;
222 _ze_full_name.clear();
226 void MEDFileFieldRepresentationLeavesArrays::setId(int& id) const
231 int MEDFileFieldRepresentationLeavesArrays::getId() const
236 std::string MEDFileFieldRepresentationLeavesArrays::getZeName() const
238 return _ze_full_name;
241 const char *MEDFileFieldRepresentationLeavesArrays::getZeNameC() const
243 return _ze_full_name.c_str();
246 void MEDFileFieldRepresentationLeavesArrays::feedSIL(vtkMutableDirectedGraph* sil, vtkIdType root, vtkVariantArray *edge, std::vector<std::string>& names) const
248 vtkIdType refId(sil->AddChild(root,edge));
249 names.push_back(_ze_name);
251 if(MEDFileFieldRepresentationTree::IsFieldMeshRegardingInfo(((operator->())->getInfo())))
253 sil->AddChild(refId,edge);
254 names.push_back(std::string());
258 void MEDFileFieldRepresentationLeavesArrays::computeFullNameInLeaves(const std::string& tsName, const std::string& meshName, const std::string& comSupStr) const
260 std::ostringstream oss3; oss3 << tsName << "/" << meshName << "/" << comSupStr << "/" << _ze_name;
261 _ze_full_name=oss3.str();
264 bool MEDFileFieldRepresentationLeavesArrays::getStatus() const
269 bool MEDFileFieldRepresentationLeavesArrays::setStatus(bool status) const
271 bool ret(_activated!=status);
276 void MEDFileFieldRepresentationLeavesArrays::appendFields(const MEDTimeReq *tr, const ParaMEDMEM::MEDFileFieldGlobsReal *globs, const ParaMEDMEM::MEDMeshMultiLev *mml, const ParaMEDMEM::MEDFileMeshStruct *mst, vtkDataSet *ds) const
278 static const int VTK_DATA_ARRAY_FREE=vtkDataArrayTemplate<double>::VTK_DATA_ARRAY_FREE;
279 static const int VTK_DATA_ARRAY_DELETE=vtkDataArrayTemplate<double>::VTK_DATA_ARRAY_DELETE;
280 tr->setNumberOfTS((operator->())->getNumberOfTS());
282 for(int timeStepId=0;timeStepId<tr->size();timeStepId++,++(*tr))
284 MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TS> f1ts((operator->())->getTimeStepAtPos(tr->getCurrent()));
285 MEDFileAnyTypeField1TS *f1tsPtr(f1ts);
286 MEDFileField1TS *f1tsPtrDbl(dynamic_cast<MEDFileField1TS *>(f1tsPtr));
287 MEDFileIntField1TS *f1tsPtrInt(dynamic_cast<MEDFileIntField1TS *>(f1tsPtr));
288 DataArray *crudeArr(0),*postProcessedArr(0);
290 crudeArr=f1tsPtrDbl->getUndergroundDataArray();
292 crudeArr=f1tsPtrInt->getUndergroundDataArray();
294 throw INTERP_KERNEL::Exception("MEDFileFieldRepresentationLeavesArrays::appendFields : only FLOAT64 and INT32 fields are dealt for the moment !");
295 MEDFileField1TSStructItem fsst(MEDFileField1TSStructItem::BuildItemFrom(f1ts,mst));
296 f1ts->loadArraysIfNecessary();
297 MEDCouplingAutoRefCountObjectPtr<DataArray> v(mml->buildDataArray(fsst,globs,crudeArr));
300 std::vector<TypeOfField> discs(f1ts->getTypesOfFieldAvailable());
302 throw INTERP_KERNEL::Exception("MEDFileFieldRepresentationLeavesArrays::appendFields : internal error ! Number of spatial discretizations must be equal to one !");
303 vtkFieldData *att(0);
308 att=ds->GetCellData();
313 att=ds->GetPointData();
318 att=ds->GetFieldData();
323 att=ds->GetFieldData();
327 throw INTERP_KERNEL::Exception("MEDFileFieldRepresentationLeavesArrays::appendFields : only CELL and NODE, GAUSS_NE and GAUSS fields are available for the moment !");
331 DataArray *vPtr(v); DataArrayDouble *vd(static_cast<DataArrayDouble *>(vPtr));
332 vtkDoubleArray *vtkd(vtkDoubleArray::New());
333 vtkd->SetNumberOfComponents(vd->getNumberOfComponents());
334 for(int i=0;i<vd->getNumberOfComponents();i++)
335 vtkd->SetComponentName(i,vd->getInfoOnComponent(i).c_str());
336 if(postProcessedArr!=crudeArr)
338 vtkd->SetArray(vd->getPointer(),vd->getNbOfElems(),0,VTK_DATA_ARRAY_FREE); vd->accessToMemArray().setSpecificDeallocator(0);
342 vtkd->SetArray(vd->getPointer(),vd->getNbOfElems(),1,VTK_DATA_ARRAY_FREE);
344 std::string name(tr->buildName(f1ts->getName()));
345 vtkd->SetName(name.c_str());
348 if(discs[0]==ON_GAUSS_PT)
351 _elga_cmp.findOrCreate(globs,f1ts->getLocsReallyUsed(),vtkd,ds,tmp);
353 if(discs[0]==ON_GAUSS_NE)
355 vtkIdTypeArray *elno(vtkIdTypeArray::New());
356 elno->SetNumberOfComponents(1);
357 vtkIdType ncell(ds->GetNumberOfCells());
358 int *pt(new int[ncell]),offset(0);
359 std::set<int> cellTypes;
360 for(vtkIdType cellId=0;cellId<ncell;cellId++)
362 vtkCell *cell(ds->GetCell(cellId));
363 int delta(cell->GetNumberOfPoints());
364 cellTypes.insert(cell->GetCellType());
368 elno->GetInformation()->Set(MEDUtilities::ELNO(),1);
369 elno->SetArray(pt,ncell,0,VTK_DATA_ARRAY_DELETE);
370 std::string nameElno("ELNO"); nameElno+="@"; nameElno+=name;
371 elno->SetName(nameElno.c_str());
372 ds->GetCellData()->AddArray(elno);
373 vtkd->GetInformation()->Set(vtkQuadratureSchemeDefinition::QUADRATURE_OFFSET_ARRAY_NAME(),elno->GetName());
374 elno->GetInformation()->Set(vtkAbstractArray::GUI_HIDE(),1);
376 vtkInformationQuadratureSchemeDefinitionVectorKey *key(vtkQuadratureSchemeDefinition::DICTIONARY());
377 for(std::set<int>::const_iterator it=cellTypes.begin();it!=cellTypes.end();it++)
379 const unsigned char *pos(std::find(MEDMeshMultiLev::PARAMEDMEM_2_VTKTYPE,MEDMeshMultiLev::PARAMEDMEM_2_VTKTYPE+MEDMeshMultiLev::PARAMEDMEM_2_VTKTYPE_LGTH,*it));
380 if(pos==MEDMeshMultiLev::PARAMEDMEM_2_VTKTYPE+MEDMeshMultiLev::PARAMEDMEM_2_VTKTYPE_LGTH)
382 INTERP_KERNEL::NormalizedCellType ct((INTERP_KERNEL::NormalizedCellType)std::distance(MEDMeshMultiLev::PARAMEDMEM_2_VTKTYPE,pos));
383 const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel(ct));
384 int nbGaussPt(cm.getNumberOfNodes()),dim(cm.getDimension());
385 vtkQuadratureSchemeDefinition *def(vtkQuadratureSchemeDefinition::New());
386 double *shape(new double[nbGaussPt*nbGaussPt]);
388 const double *gsCoords(MEDCouplingFieldDiscretizationGaussNE::GetLocsFromGeometricType(ct,dummy));
389 const double *refCoords(MEDCouplingFieldDiscretizationGaussNE::GetRefCoordsFromGeometricType(ct,dummy));
390 const double *weights(MEDCouplingFieldDiscretizationGaussNE::GetWeightArrayFromGeometricType(ct,dummy));
391 std::vector<double> gsCoords2(gsCoords,gsCoords+nbGaussPt*dim),refCoords2(refCoords,refCoords+nbGaussPt*dim);
392 INTERP_KERNEL::GaussInfo calculator(ct,gsCoords2,nbGaussPt,refCoords2,nbGaussPt);
393 calculator.initLocalInfo();
394 for(int i=0;i<nbGaussPt;i++)
396 const double *pt0(calculator.getFunctionValues(i));
397 std::copy(pt0,pt0+nbGaussPt,shape+nbGaussPt*i);
399 def->Initialize(*it,nbGaussPt,nbGaussPt,shape,const_cast<double *>(weights));
401 key->Set(elno->GetInformation(),def,*it);
402 key->Set(vtkd->GetInformation(),def,*it);
411 DataArray *vPtr(v); DataArrayInt *vi(static_cast<DataArrayInt *>(vPtr));
412 vtkIntArray *vtkd(vtkIntArray::New());
413 vtkd->SetNumberOfComponents(vi->getNumberOfComponents());
414 for(int i=0;i<vi->getNumberOfComponents();i++)
415 vtkd->SetComponentName(i,vi->getVarOnComponent(i).c_str());
416 if(postProcessedArr!=crudeArr)
418 vtkd->SetArray(vi->getPointer(),vi->getNbOfElems(),0,VTK_DATA_ARRAY_FREE); vi->accessToMemArray().setSpecificDeallocator(0);
422 vtkd->SetArray(vi->getPointer(),vi->getNbOfElems(),1,VTK_DATA_ARRAY_FREE);
424 std::string name(tr->buildName(f1ts->getName()));
425 vtkd->SetName(name.c_str());
430 throw INTERP_KERNEL::Exception("MEDFileFieldRepresentationLeavesArrays::appendFields : only FLOAT64 and INT32 fields are dealt for the moment ! Internal Error !");
434 void MEDFileFieldRepresentationLeavesArrays::appendELGAIfAny(vtkDataSet *ds) const
436 _elga_cmp.appendELGAIfAny(ds);
441 MEDFileFieldRepresentationLeaves::MEDFileFieldRepresentationLeaves():_cached_ds(0)
445 MEDFileFieldRepresentationLeaves::MEDFileFieldRepresentationLeaves(const std::vector< ParaMEDMEM::MEDCouplingAutoRefCountObjectPtr<ParaMEDMEM::MEDFileAnyTypeFieldMultiTS> >& arr,
446 const ParaMEDMEM::MEDCouplingAutoRefCountObjectPtr<ParaMEDMEM::MEDFileFastCellSupportComparator>& fsp):_arrays(arr.size()),_fsp(fsp),_cached_ds(0)
448 for(std::size_t i=0;i<arr.size();i++)
449 _arrays[i]=MEDFileFieldRepresentationLeavesArrays(arr[i]);
452 MEDFileFieldRepresentationLeaves::~MEDFileFieldRepresentationLeaves()
455 _cached_ds->Delete();
458 bool MEDFileFieldRepresentationLeaves::empty() const
460 const MEDFileFastCellSupportComparator *fcscp(_fsp);
461 return fcscp==0 || _arrays.empty();
464 void MEDFileFieldRepresentationLeaves::setId(int& id) const
466 for(std::vector<MEDFileFieldRepresentationLeavesArrays>::const_iterator it=_arrays.begin();it!=_arrays.end();it++)
470 std::string MEDFileFieldRepresentationLeaves::getMeshName() const
472 return _arrays[0]->getMeshName();
475 int MEDFileFieldRepresentationLeaves::getNumberOfArrays() const
477 return (int)_arrays.size();
480 int MEDFileFieldRepresentationLeaves::getNumberOfTS() const
482 return _arrays[0]->getNumberOfTS();
485 void MEDFileFieldRepresentationLeaves::computeFullNameInLeaves(const std::string& tsName, const std::string& meshName, const std::string& comSupStr) const
487 for(std::vector<MEDFileFieldRepresentationLeavesArrays>::const_iterator it=_arrays.begin();it!=_arrays.end();it++)
488 (*it).computeFullNameInLeaves(tsName,meshName,comSupStr);
492 * \param [in] ms is the meshes pointer. It can be used only for information of geometric types. No special processing will be requested on ms.
494 void MEDFileFieldRepresentationLeaves::feedSIL(const ParaMEDMEM::MEDFileMeshes *ms, const std::string& meshName, vtkMutableDirectedGraph* sil, vtkIdType root, vtkVariantArray *edge, std::vector<std::string>& names) const
496 vtkIdType root2(sil->AddChild(root,edge));
497 names.push_back(std::string("Arrs"));
498 for(std::vector<MEDFileFieldRepresentationLeavesArrays>::const_iterator it=_arrays.begin();it!=_arrays.end();it++)
499 (*it).feedSIL(sil,root2,edge,names);
501 vtkIdType root3(sil->AddChild(root,edge));
502 names.push_back(std::string("InfoOnGeoType"));
503 const ParaMEDMEM::MEDFileMesh *m(0);
505 m=ms->getMeshWithName(meshName);
506 const ParaMEDMEM::MEDFileFastCellSupportComparator *fsp(_fsp);
507 if(!fsp || fsp->getNumberOfTS()==0)
509 std::vector< INTERP_KERNEL::NormalizedCellType > gts(fsp->getGeoTypesAt(0,m));
510 for(std::vector< INTERP_KERNEL::NormalizedCellType >::const_iterator it2=gts.begin();it2!=gts.end();it2++)
512 const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel(*it2));
513 std::string cmStr(cm.getRepr()); cmStr=cmStr.substr(5);//skip "NORM_"
514 sil->AddChild(root3,edge);
515 names.push_back(cmStr);
519 bool MEDFileFieldRepresentationLeaves::containId(int id) const
521 for(std::vector<MEDFileFieldRepresentationLeavesArrays>::const_iterator it=_arrays.begin();it!=_arrays.end();it++)
522 if((*it).getId()==id)
527 bool MEDFileFieldRepresentationLeaves::containZeName(const char *name, int& id) const
529 for(std::vector<MEDFileFieldRepresentationLeavesArrays>::const_iterator it=_arrays.begin();it!=_arrays.end();it++)
530 if((*it).getZeName()==name)
538 bool MEDFileFieldRepresentationLeaves::isActivated() const
540 for(std::vector<MEDFileFieldRepresentationLeavesArrays>::const_iterator it=_arrays.begin();it!=_arrays.end();it++)
541 if((*it).getStatus())
546 void MEDFileFieldRepresentationLeaves::printMySelf(std::ostream& os) const
548 for(std::vector<MEDFileFieldRepresentationLeavesArrays>::const_iterator it0=_arrays.begin();it0!=_arrays.end();it0++)
550 os << " - " << (*it0).getZeName() << " (";
551 if((*it0).getStatus())
555 os << ")" << std::endl;
559 void MEDFileFieldRepresentationLeaves::activateAllArrays() const
561 for(std::vector<MEDFileFieldRepresentationLeavesArrays>::const_iterator it=_arrays.begin();it!=_arrays.end();it++)
562 (*it).setStatus(true);
565 const MEDFileFieldRepresentationLeavesArrays& MEDFileFieldRepresentationLeaves::getLeafArr(int id) const
567 for(std::vector<MEDFileFieldRepresentationLeavesArrays>::const_iterator it=_arrays.begin();it!=_arrays.end();it++)
568 if((*it).getId()==id)
570 throw INTERP_KERNEL::Exception("MEDFileFieldRepresentationLeaves::getLeafArr ! No such id !");
573 std::vector<double> MEDFileFieldRepresentationLeaves::getTimeSteps(const TimeKeeper& tk) const
576 throw INTERP_KERNEL::Exception("MEDFileFieldRepresentationLeaves::getTimeSteps : the array size must be at least of size one !");
577 std::vector<double> ret;
578 std::vector< std::pair<int,int> > dtits(_arrays[0]->getTimeSteps(ret));
579 return tk.getTimeStepsRegardingPolicy(dtits,ret);
582 std::vector< std::pair<int,int> > MEDFileFieldRepresentationLeaves::getTimeStepsInCoarseMEDFileFormat(std::vector<double>& ts) const
585 return _arrays[0]->getTimeSteps(ts);
589 return std::vector< std::pair<int,int> >();
593 std::string MEDFileFieldRepresentationLeaves::getHumanReadableOverviewOfTS() const
595 std::ostringstream oss;
596 oss << _arrays[0]->getNumberOfTS() << " time steps [" << _arrays[0]->getDtUnit() << "]\n(";
597 std::vector<double> ret1;
598 std::vector< std::pair<int,int> > ret2(getTimeStepsInCoarseMEDFileFormat(ret1));
599 std::size_t sz(ret1.size());
600 for(std::size_t i=0;i<sz;i++)
602 oss << ret1[i] << " (" << ret2[i].first << "," << ret2[i].second << ")";
605 std::string tmp(oss.str());
606 if(tmp.size()>200 && i!=sz-1)
616 void MEDFileFieldRepresentationLeaves::appendFields(const MEDTimeReq *tr, const ParaMEDMEM::MEDFileFieldGlobsReal *globs, const ParaMEDMEM::MEDMeshMultiLev *mml, const ParaMEDMEM::MEDFileMeshes *meshes, vtkDataSet *ds) const
619 throw INTERP_KERNEL::Exception("MEDFileFieldRepresentationLeaves::appendFields : internal error !");
620 MEDCouplingAutoRefCountObjectPtr<MEDFileMeshStruct> mst(MEDFileMeshStruct::New(meshes->getMeshWithName(_arrays[0]->getMeshName().c_str())));
621 for(std::vector<MEDFileFieldRepresentationLeavesArrays>::const_iterator it=_arrays.begin();it!=_arrays.end();it++)
622 if((*it).getStatus())
624 (*it).appendFields(tr,globs,mml,mst,ds);
625 (*it).appendELGAIfAny(ds);
629 vtkUnstructuredGrid *MEDFileFieldRepresentationLeaves::buildVTKInstanceNoTimeInterpolationUnstructured(MEDUMeshMultiLev *mm) const
631 static const int VTK_DATA_ARRAY_FREE=vtkDataArrayTemplate<double>::VTK_DATA_ARRAY_FREE;
632 DataArrayDouble *coordsMC(0);
633 DataArrayByte *typesMC(0);
634 DataArrayInt *cellLocationsMC(0),*cellsMC(0),*faceLocationsMC(0),*facesMC(0);
635 bool statusOfCoords(mm->buildVTUArrays(coordsMC,typesMC,cellLocationsMC,cellsMC,faceLocationsMC,facesMC));
636 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> coordsSafe(coordsMC);
637 MEDCouplingAutoRefCountObjectPtr<DataArrayByte> typesSafe(typesMC);
638 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> cellLocationsSafe(cellLocationsMC),cellsSafe(cellsMC),faceLocationsSafe(faceLocationsMC),facesSafe(facesMC);
640 int nbOfCells(typesSafe->getNbOfElems());
641 vtkUnstructuredGrid *ret(vtkUnstructuredGrid::New());
642 vtkUnsignedCharArray *cellTypes(vtkUnsignedCharArray::New());
643 cellTypes->SetArray(reinterpret_cast<unsigned char *>(typesSafe->getPointer()),nbOfCells,0,VTK_DATA_ARRAY_FREE); typesSafe->accessToMemArray().setSpecificDeallocator(0);
644 vtkIdTypeArray *cellLocations(vtkIdTypeArray::New());
645 cellLocations->SetArray(cellLocationsSafe->getPointer(),nbOfCells,0,VTK_DATA_ARRAY_FREE); cellLocationsSafe->accessToMemArray().setSpecificDeallocator(0);
646 vtkCellArray *cells(vtkCellArray::New());
647 vtkIdTypeArray *cells2(vtkIdTypeArray::New());
648 cells2->SetArray(cellsSafe->getPointer(),cellsSafe->getNbOfElems(),0,VTK_DATA_ARRAY_FREE); cellsSafe->accessToMemArray().setSpecificDeallocator(0);
649 cells->SetCells(nbOfCells,cells2);
651 if(faceLocationsMC!=0 && facesMC!=0)
653 vtkIdTypeArray *faces(vtkIdTypeArray::New());
654 faces->SetArray(facesSafe->getPointer(),facesSafe->getNbOfElems(),0,VTK_DATA_ARRAY_FREE); facesSafe->accessToMemArray().setSpecificDeallocator(0);
655 vtkIdTypeArray *faceLocations(vtkIdTypeArray::New());
656 faceLocations->SetArray(faceLocationsSafe->getPointer(),faceLocationsSafe->getNbOfElems(),0,VTK_DATA_ARRAY_FREE); faceLocationsSafe->accessToMemArray().setSpecificDeallocator(0);
657 ret->SetCells(cellTypes,cellLocations,cells,faceLocations,faces);
658 faceLocations->Delete();
662 ret->SetCells(cellTypes,cellLocations,cells);
664 cellLocations->Delete();
666 vtkPoints *pts(vtkPoints::New());
667 vtkDoubleArray *pts2(vtkDoubleArray::New());
668 pts2->SetNumberOfComponents(3);
671 pts2->SetArray(coordsSafe->getPointer(),coordsSafe->getNbOfElems(),0,VTK_DATA_ARRAY_FREE);
672 coordsSafe->accessToMemArray().setSpecificDeallocator(0);
675 pts2->SetArray(coordsSafe->getPointer(),coordsSafe->getNbOfElems(),1,VTK_DATA_ARRAY_FREE);
684 vtkRectilinearGrid *MEDFileFieldRepresentationLeaves::buildVTKInstanceNoTimeInterpolationCartesian(ParaMEDMEM::MEDCMeshMultiLev *mm) const
686 static const int VTK_DATA_ARRAY_FREE=vtkDataArrayTemplate<double>::VTK_DATA_ARRAY_FREE;
688 std::vector< DataArrayDouble * > arrs(mm->buildVTUArrays(isInternal));
689 vtkDoubleArray *vtkTmp(0);
690 vtkRectilinearGrid *ret(vtkRectilinearGrid::New());
691 std::size_t dim(arrs.size());
693 throw INTERP_KERNEL::Exception("buildVTKInstanceNoTimeInterpolationCartesian : dimension must be in [1,3] !");
694 int sizePerAxe[3]={1,1,1};
695 sizePerAxe[0]=arrs[0]->getNbOfElems();
697 sizePerAxe[1]=arrs[1]->getNbOfElems();
699 sizePerAxe[2]=arrs[2]->getNbOfElems();
700 ret->SetDimensions(sizePerAxe[0],sizePerAxe[1],sizePerAxe[2]);
701 vtkTmp=vtkDoubleArray::New();
702 vtkTmp->SetNumberOfComponents(1);
704 vtkTmp->SetArray(arrs[0]->getPointer(),arrs[0]->getNbOfElems(),1,VTK_DATA_ARRAY_FREE);
706 { vtkTmp->SetArray(arrs[0]->getPointer(),arrs[0]->getNbOfElems(),0,VTK_DATA_ARRAY_FREE); arrs[0]->accessToMemArray().setSpecificDeallocator(0); }
707 ret->SetXCoordinates(vtkTmp);
712 vtkTmp=vtkDoubleArray::New();
713 vtkTmp->SetNumberOfComponents(1);
715 vtkTmp->SetArray(arrs[1]->getPointer(),arrs[1]->getNbOfElems(),1,VTK_DATA_ARRAY_FREE);
717 { vtkTmp->SetArray(arrs[1]->getPointer(),arrs[1]->getNbOfElems(),0,VTK_DATA_ARRAY_FREE); arrs[1]->accessToMemArray().setSpecificDeallocator(0); }
718 ret->SetYCoordinates(vtkTmp);
724 vtkTmp=vtkDoubleArray::New();
725 vtkTmp->SetNumberOfComponents(1);
727 vtkTmp->SetArray(arrs[2]->getPointer(),arrs[2]->getNbOfElems(),1,VTK_DATA_ARRAY_FREE);
729 { vtkTmp->SetArray(arrs[2]->getPointer(),arrs[2]->getNbOfElems(),0,VTK_DATA_ARRAY_FREE); arrs[2]->accessToMemArray().setSpecificDeallocator(0); }
730 ret->SetZCoordinates(vtkTmp);
737 vtkStructuredGrid *MEDFileFieldRepresentationLeaves::buildVTKInstanceNoTimeInterpolationCurveLinear(ParaMEDMEM::MEDCurveLinearMeshMultiLev *mm) const
739 static const int VTK_DATA_ARRAY_FREE=vtkDataArrayTemplate<double>::VTK_DATA_ARRAY_FREE;
740 int meshStr[3]={1,1,1};
741 DataArrayDouble *coords(0);
742 std::vector<int> nodeStrct;
744 mm->buildVTUArrays(coords,nodeStrct,isInternal);
745 std::size_t dim(nodeStrct.size());
747 throw INTERP_KERNEL::Exception("buildVTKInstanceNoTimeInterpolationCurveLinear : dimension must be in [1,3] !");
748 meshStr[0]=nodeStrct[0];
750 meshStr[1]=nodeStrct[1];
752 meshStr[2]=nodeStrct[2];
753 vtkStructuredGrid *ret(vtkStructuredGrid::New());
754 ret->SetDimensions(meshStr[0],meshStr[1],meshStr[2]);
755 vtkDoubleArray *da(vtkDoubleArray::New());
756 da->SetNumberOfComponents(3);
757 if(coords->getNumberOfComponents()==3)
760 da->SetArray(coords->getPointer(),coords->getNbOfElems(),1,VTK_DATA_ARRAY_FREE);//VTK has not the ownership of double * because MEDLoader main struct has it !
762 { da->SetArray(coords->getPointer(),coords->getNbOfElems(),0,VTK_DATA_ARRAY_FREE); coords->accessToMemArray().setSpecificDeallocator(0); }
766 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> coords2(coords->changeNbOfComponents(3,0.));
767 da->SetArray(coords2->getPointer(),coords2->getNbOfElems(),0,VTK_DATA_ARRAY_FREE);//let VTK deal with double *
768 coords2->accessToMemArray().setSpecificDeallocator(0);
771 vtkPoints *points=vtkPoints::New();
772 ret->SetPoints(points);
779 vtkDataSet *MEDFileFieldRepresentationLeaves::buildVTKInstanceNoTimeInterpolation(const MEDTimeReq *tr, const MEDFileFieldGlobsReal *globs, const ParaMEDMEM::MEDFileMeshes *meshes) const
781 static const int VTK_DATA_ARRAY_FREE=vtkDataArrayTemplate<double>::VTK_DATA_ARRAY_FREE;
783 //_fsp->isDataSetSupportEqualToThePreviousOne(i,globs);
784 MEDCouplingAutoRefCountObjectPtr<MEDMeshMultiLev> mml(_fsp->buildFromScratchDataSetSupport(0,globs));//0=timestep Id. Make the hypothesis that support does not change
785 MEDCouplingAutoRefCountObjectPtr<MEDMeshMultiLev> mml2(mml->prepare());
786 MEDMeshMultiLev *ptMML2(mml2);
789 MEDUMeshMultiLev *ptUMML2(dynamic_cast<MEDUMeshMultiLev *>(ptMML2));
790 MEDCMeshMultiLev *ptCMML2(dynamic_cast<MEDCMeshMultiLev *>(ptMML2));
791 MEDCurveLinearMeshMultiLev *ptCLMML2(dynamic_cast<MEDCurveLinearMeshMultiLev *>(ptMML2));
795 ret=buildVTKInstanceNoTimeInterpolationUnstructured(ptUMML2);
799 ret=buildVTKInstanceNoTimeInterpolationCartesian(ptCMML2);
803 ret=buildVTKInstanceNoTimeInterpolationCurveLinear(ptCLMML2);
806 throw INTERP_KERNEL::Exception("MEDFileFieldRepresentationLeaves::buildVTKInstanceNoTimeInterpolation : unrecognized mesh ! Supported for the moment unstructured, cartesian, curvelinear !");
807 _cached_ds=ret->NewInstance();
808 _cached_ds->ShallowCopy(ret);
812 ret=_cached_ds->NewInstance();
813 ret->ShallowCopy(_cached_ds);
816 appendFields(tr,globs,mml,meshes,ret);
817 // The arrays links to mesh
818 DataArrayInt *famCells(0),*numCells(0);
819 bool noCpyFamCells(false),noCpyNumCells(false);
820 ptMML2->retrieveFamilyIdsOnCells(famCells,noCpyFamCells);
823 vtkIntArray *vtkTab(vtkIntArray::New());
824 vtkTab->SetNumberOfComponents(1);
825 vtkTab->SetName(MEDFileFieldRepresentationLeavesArrays::FAMILY_ID_CELL_NAME);
827 vtkTab->SetArray(famCells->getPointer(),famCells->getNbOfElems(),1,VTK_DATA_ARRAY_FREE);
829 { vtkTab->SetArray(famCells->getPointer(),famCells->getNbOfElems(),0,VTK_DATA_ARRAY_FREE); famCells->accessToMemArray().setSpecificDeallocator(0); }
830 ret->GetCellData()->AddArray(vtkTab);
834 ptMML2->retrieveNumberIdsOnCells(numCells,noCpyNumCells);
837 vtkIntArray *vtkTab(vtkIntArray::New());
838 vtkTab->SetNumberOfComponents(1);
839 vtkTab->SetName(MEDFileFieldRepresentationLeavesArrays::NUM_ID_CELL_NAME);
841 vtkTab->SetArray(numCells->getPointer(),numCells->getNbOfElems(),1,VTK_DATA_ARRAY_FREE);
843 { vtkTab->SetArray(numCells->getPointer(),numCells->getNbOfElems(),0,VTK_DATA_ARRAY_FREE); numCells->accessToMemArray().setSpecificDeallocator(0); }
844 ret->GetCellData()->AddArray(vtkTab);
848 // The arrays links to mesh
849 DataArrayInt *famNodes(0),*numNodes(0);
850 bool noCpyFamNodes(false),noCpyNumNodes(false);
851 ptMML2->retrieveFamilyIdsOnNodes(famNodes,noCpyFamNodes);
854 vtkIntArray *vtkTab(vtkIntArray::New());
855 vtkTab->SetNumberOfComponents(1);
856 vtkTab->SetName(MEDFileFieldRepresentationLeavesArrays::FAMILY_ID_NODE_NAME);
858 vtkTab->SetArray(famNodes->getPointer(),famNodes->getNbOfElems(),1,VTK_DATA_ARRAY_FREE);
860 { vtkTab->SetArray(famNodes->getPointer(),famNodes->getNbOfElems(),0,VTK_DATA_ARRAY_FREE); famNodes->accessToMemArray().setSpecificDeallocator(0); }
861 ret->GetPointData()->AddArray(vtkTab);
865 ptMML2->retrieveNumberIdsOnNodes(numNodes,noCpyNumNodes);
868 vtkIntArray *vtkTab(vtkIntArray::New());
869 vtkTab->SetNumberOfComponents(1);
870 vtkTab->SetName(MEDFileFieldRepresentationLeavesArrays::NUM_ID_NODE_NAME);
872 vtkTab->SetArray(numNodes->getPointer(),numNodes->getNbOfElems(),1,VTK_DATA_ARRAY_FREE);
874 { vtkTab->SetArray(numNodes->getPointer(),numNodes->getNbOfElems(),0,VTK_DATA_ARRAY_FREE); numNodes->accessToMemArray().setSpecificDeallocator(0); }
875 ret->GetPointData()->AddArray(vtkTab);
882 //////////////////////
884 MEDFileFieldRepresentationTree::MEDFileFieldRepresentationTree()
888 int MEDFileFieldRepresentationTree::getNumberOfLeavesArrays() const
891 for(std::vector< std::vector< std::vector< MEDFileFieldRepresentationLeaves > > >::const_iterator it0=_data_structure.begin();it0!=_data_structure.end();it0++)
892 for(std::vector< std::vector< MEDFileFieldRepresentationLeaves > >::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++)
893 for(std::vector< MEDFileFieldRepresentationLeaves >::const_iterator it2=(*it1).begin();it2!=(*it1).end();it2++)
894 ret+=(*it2).getNumberOfArrays();
898 void MEDFileFieldRepresentationTree::assignIds() const
901 for(std::vector< std::vector< std::vector< MEDFileFieldRepresentationLeaves > > >::const_iterator it0=_data_structure.begin();it0!=_data_structure.end();it0++)
902 for(std::vector< std::vector< MEDFileFieldRepresentationLeaves > >::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++)
903 for(std::vector< MEDFileFieldRepresentationLeaves >::const_iterator it2=(*it1).begin();it2!=(*it1).end();it2++)
907 void MEDFileFieldRepresentationTree::computeFullNameInLeaves() const
909 std::size_t it0Cnt(0);
910 for(std::vector< std::vector< std::vector< MEDFileFieldRepresentationLeaves > > >::const_iterator it0=_data_structure.begin();it0!=_data_structure.end();it0++,it0Cnt++)
912 std::ostringstream oss; oss << MEDFileFieldRepresentationLeavesArrays::TS_STR << it0Cnt;
913 std::string tsName(oss.str());
914 for(std::vector< std::vector< MEDFileFieldRepresentationLeaves > >::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++)
916 std::string meshName((*it1)[0].getMeshName());
917 std::size_t it2Cnt(0);
918 for(std::vector< MEDFileFieldRepresentationLeaves >::const_iterator it2=(*it1).begin();it2!=(*it1).end();it2++,it2Cnt++)
920 std::ostringstream oss2; oss2 << MEDFileFieldRepresentationLeavesArrays::COM_SUP_STR << it2Cnt;
921 std::string comSupStr(oss2.str());
922 (*it2).computeFullNameInLeaves(tsName,meshName,comSupStr);
928 void MEDFileFieldRepresentationTree::activateTheFirst() const
930 for(std::vector< std::vector< std::vector< MEDFileFieldRepresentationLeaves > > >::const_iterator it0=_data_structure.begin();it0!=_data_structure.end();it0++)
931 for(std::vector< std::vector< MEDFileFieldRepresentationLeaves > >::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++)
932 for(std::vector< MEDFileFieldRepresentationLeaves >::const_iterator it2=(*it1).begin();it2!=(*it1).end();it2++)
934 (*it2).activateAllArrays();
939 void MEDFileFieldRepresentationTree::feedSIL(vtkMutableDirectedGraph* sil, vtkIdType root, vtkVariantArray *edge, std::vector<std::string>& names) const
941 std::size_t it0Cnt(0);
942 for(std::vector< std::vector< std::vector< MEDFileFieldRepresentationLeaves > > >::const_iterator it0=_data_structure.begin();it0!=_data_structure.end();it0++,it0Cnt++)
944 vtkIdType InfoOnTSId(sil->AddChild(root,edge));
945 names.push_back((*it0)[0][0].getHumanReadableOverviewOfTS());
947 vtkIdType NbOfTSId(sil->AddChild(InfoOnTSId,edge));
948 std::vector<double> ts;
949 std::vector< std::pair<int,int> > dtits((*it0)[0][0].getTimeStepsInCoarseMEDFileFormat(ts));
950 std::size_t nbOfTS(dtits.size());
951 std::ostringstream oss3; oss3 << nbOfTS;
952 names.push_back(oss3.str());
953 for(std::size_t i=0;i<nbOfTS;i++)
955 std::ostringstream oss4; oss4 << dtits[i].first;
956 vtkIdType DtId(sil->AddChild(NbOfTSId,edge));
957 names.push_back(oss4.str());
958 std::ostringstream oss5; oss5 << dtits[i].second;
959 vtkIdType ItId(sil->AddChild(DtId,edge));
960 names.push_back(oss5.str());
961 std::ostringstream oss6; oss6 << ts[i];
962 sil->AddChild(ItId,edge);
963 names.push_back(oss6.str());
966 std::ostringstream oss; oss << MEDFileFieldRepresentationLeavesArrays::TS_STR << it0Cnt;
967 std::string tsName(oss.str());
968 vtkIdType typeId0(sil->AddChild(root,edge));
969 names.push_back(tsName);
970 for(std::vector< std::vector< MEDFileFieldRepresentationLeaves > >::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++)
972 std::string meshName((*it1)[0].getMeshName());
973 vtkIdType typeId1(sil->AddChild(typeId0,edge));
974 names.push_back(meshName);
975 std::size_t it2Cnt(0);
976 for(std::vector< MEDFileFieldRepresentationLeaves >::const_iterator it2=(*it1).begin();it2!=(*it1).end();it2++,it2Cnt++)
978 std::ostringstream oss2; oss2 << MEDFileFieldRepresentationLeavesArrays::COM_SUP_STR << it2Cnt;
979 std::string comSupStr(oss2.str());
980 vtkIdType typeId2(sil->AddChild(typeId1,edge));
981 names.push_back(comSupStr);
982 (*it2).feedSIL(_ms,meshName,sil,typeId2,edge,names);
988 std::string MEDFileFieldRepresentationTree::feedSILForFamsAndGrps(vtkMutableDirectedGraph* sil, vtkIdType root, vtkVariantArray *edge, std::vector<std::string>& names) const
990 int dummy0(0),dummy1(0),dummy2(0);
991 const MEDFileFieldRepresentationLeaves& leaf(getTheSingleActivated(dummy0,dummy1,dummy2));
992 std::string ret(leaf.getMeshName());
995 for(;i<_ms->getNumberOfMeshes();i++)
997 m=_ms->getMeshAtPos(i);
998 if(m->getName()==ret)
1001 if(i==_ms->getNumberOfMeshes())
1002 throw INTERP_KERNEL::Exception("MEDFileFieldRepresentationTree::feedSILForFamsAndGrps : internal error #0 !");
1003 vtkIdType typeId0(sil->AddChild(root,edge));
1004 names.push_back(m->getName());
1006 vtkIdType typeId1(sil->AddChild(typeId0,edge));
1007 names.push_back(std::string(ROOT_OF_GRPS_IN_TREE));
1008 std::vector<std::string> grps(m->getGroupsNames());
1009 for(std::vector<std::string>::const_iterator it0=grps.begin();it0!=grps.end();it0++)
1011 vtkIdType typeId2(sil->AddChild(typeId1,edge));
1012 names.push_back(*it0);
1013 std::vector<std::string> famsOnGrp(m->getFamiliesOnGroup((*it0).c_str()));
1014 for(std::vector<std::string>::const_iterator it1=famsOnGrp.begin();it1!=famsOnGrp.end();it1++)
1016 sil->AddChild(typeId2,edge);
1017 names.push_back((*it1).c_str());
1021 vtkIdType typeId11(sil->AddChild(typeId0,edge));
1022 names.push_back(std::string(ROOT_OF_FAM_IDS_IN_TREE));
1023 std::vector<std::string> fams(m->getFamiliesNames());
1024 for(std::vector<std::string>::const_iterator it00=fams.begin();it00!=fams.end();it00++)
1026 sil->AddChild(typeId11,edge);
1027 int famId(m->getFamilyId((*it00).c_str()));
1028 std::ostringstream oss; oss << (*it00) << MEDFileFieldRepresentationLeavesArrays::ZE_SEP << famId;
1029 names.push_back(oss.str());
1034 const MEDFileFieldRepresentationLeavesArrays& MEDFileFieldRepresentationTree::getLeafArr(int id) const
1036 for(std::vector< std::vector< std::vector< MEDFileFieldRepresentationLeaves > > >::const_iterator it0=_data_structure.begin();it0!=_data_structure.end();it0++)
1037 for(std::vector< std::vector< MEDFileFieldRepresentationLeaves > >::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++)
1038 for(std::vector< MEDFileFieldRepresentationLeaves >::const_iterator it2=(*it1).begin();it2!=(*it1).end();it2++)
1039 if((*it2).containId(id))
1040 return (*it2).getLeafArr(id);
1041 throw INTERP_KERNEL::Exception("Internal error in MEDFileFieldRepresentationTree::getLeafArr !");
1044 std::string MEDFileFieldRepresentationTree::getNameOf(int id) const
1046 const MEDFileFieldRepresentationLeavesArrays& elt(getLeafArr(id));
1047 return elt.getZeName();
1050 const char *MEDFileFieldRepresentationTree::getNameOfC(int id) const
1052 const MEDFileFieldRepresentationLeavesArrays& elt(getLeafArr(id));
1053 return elt.getZeNameC();
1056 bool MEDFileFieldRepresentationTree::getStatusOf(int id) const
1058 const MEDFileFieldRepresentationLeavesArrays& elt(getLeafArr(id));
1059 return elt.getStatus();
1062 int MEDFileFieldRepresentationTree::getIdHavingZeName(const char *name) const
1065 for(std::vector< std::vector< std::vector< MEDFileFieldRepresentationLeaves > > >::const_iterator it0=_data_structure.begin();it0!=_data_structure.end();it0++)
1066 for(std::vector< std::vector< MEDFileFieldRepresentationLeaves > >::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++)
1067 for(std::vector< MEDFileFieldRepresentationLeaves >::const_iterator it2=(*it1).begin();it2!=(*it1).end();it2++)
1068 if((*it2).containZeName(name,ret))
1070 std::ostringstream msg; msg << "MEDFileFieldRepresentationTree::getIdHavingZeName : No such a name \"" << name << "\" !";
1071 throw INTERP_KERNEL::Exception(msg.str().c_str());
1074 bool MEDFileFieldRepresentationTree::changeStatusOfAndUpdateToHaveCoherentVTKDataSet(int id, bool status) const
1076 const MEDFileFieldRepresentationLeavesArrays& elt(getLeafArr(id));
1077 bool ret(elt.setStatus(status));//to be implemented
1081 int MEDFileFieldRepresentationTree::getMaxNumberOfTimeSteps() const
1084 for(std::vector< std::vector< std::vector< MEDFileFieldRepresentationLeaves > > >::const_iterator it0=_data_structure.begin();it0!=_data_structure.end();it0++)
1085 for(std::vector< std::vector< MEDFileFieldRepresentationLeaves > >::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++)
1086 for(std::vector< MEDFileFieldRepresentationLeaves >::const_iterator it2=(*it1).begin();it2!=(*it1).end();it2++)
1087 ret=std::max(ret,(*it2).getNumberOfTS());
1094 void MEDFileFieldRepresentationTree::loadMainStructureOfFile(const char *fileName, bool isMEDOrSauv, int iPart, int nbOfParts)
1098 if((iPart==-1 && nbOfParts==-1) || (iPart==0 && nbOfParts==1))
1100 _ms=MEDFileMeshes::New(fileName);
1101 _fields=MEDFileFields::New(fileName,false);//false is important to not read the values
1105 #ifdef MEDREADER_USE_MPI
1106 _ms=ParaMEDFileMeshes::New(iPart,nbOfParts,fileName);
1107 _fields=MEDFileFields::LoadPartOf(fileName,false,_ms);//false is important to not read the values
1109 std::ostringstream oss; oss << "MEDFileFieldRepresentationTree::loadMainStructureOfFile : request for iPart/nbOfParts=" << iPart << "/" << nbOfParts << " whereas Plugin not compiled with MPI !";
1110 throw INTERP_KERNEL::Exception(oss.str().c_str());
1116 MEDCouplingAutoRefCountObjectPtr<ParaMEDMEM::SauvReader> sr(ParaMEDMEM::SauvReader::New(fileName));
1117 MEDCouplingAutoRefCountObjectPtr<ParaMEDMEM::MEDFileData> mfd(sr->loadInMEDFileDS());
1118 _ms=mfd->getMeshes(); _ms->incrRef();
1119 int nbMeshes(_ms->getNumberOfMeshes());
1120 for(int i=0;i<nbMeshes;i++)
1122 ParaMEDMEM::MEDFileMesh *tmp(_ms->getMeshAtPos(i));
1123 ParaMEDMEM::MEDFileUMesh *tmp2(dynamic_cast<ParaMEDMEM::MEDFileUMesh *>(tmp));
1125 tmp2->forceComputationOfParts();
1127 _fields=mfd->getFields();
1128 if((ParaMEDMEM::MEDFileFields *)_fields)
1131 if(!((ParaMEDMEM::MEDFileFields *)_fields))
1133 _fields=BuildFieldFromMeshes(_ms);
1137 AppendFieldFromMeshes(_ms,_fields);
1139 _fields->removeFieldsWithoutAnyTimeStep();
1140 std::vector<std::string> meshNames(_ms->getMeshesNames());
1141 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFields> > fields_per_mesh(meshNames.size());
1142 for(std::size_t i=0;i<meshNames.size();i++)
1144 fields_per_mesh[i]=_fields->partOfThisLyingOnSpecifiedMeshName(meshNames[i].c_str());
1146 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS > > allFMTSLeavesToDisplaySafe;
1148 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFields> >::const_iterator fields=fields_per_mesh.begin();fields!=fields_per_mesh.end();fields++)
1150 for(int j=0;j<(*fields)->getNumberOfFields();j++)
1152 MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> fmts((*fields)->getFieldAtPos((int)j));
1153 std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTS > > tmp(fmts->splitDiscretizations());
1155 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTS > >::const_iterator it=tmp.begin();it!=tmp.end();it++)
1157 if(!(*it)->presenceOfMultiDiscPerGeoType())
1158 allFMTSLeavesToDisplaySafe.push_back(*it);
1160 {// The case of some parts of field have more than one discretization per geo type.
1161 std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTS > > subTmp((*it)->splitMultiDiscrPerGeoTypes());
1162 std::size_t it0Cnt(0);
1163 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTS > >::iterator it0=subTmp.begin();it0!=subTmp.end();it0++,it0Cnt++)//not const because setName
1165 std::ostringstream oss; oss << (*it0)->getName() << "_" << std::setfill('M') << std::setw(3) << it0Cnt;
1166 (*it0)->setName(oss.str());
1167 allFMTSLeavesToDisplaySafe.push_back(*it0);
1174 std::vector< MEDFileAnyTypeFieldMultiTS *> allFMTSLeavesToDisplay(allFMTSLeavesToDisplaySafe.size());
1175 for(std::size_t i=0;i<allFMTSLeavesToDisplaySafe.size();i++)
1177 allFMTSLeavesToDisplay[i]=allFMTSLeavesToDisplaySafe[i];
1179 std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > allFMTSLeavesPerTimeSeries(MEDFileAnyTypeFieldMultiTS::SplitIntoCommonTimeSeries(allFMTSLeavesToDisplay));
1180 // memory safety part
1181 std::vector< std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> > > allFMTSLeavesPerTimeSeriesSafe(allFMTSLeavesPerTimeSeries.size());
1182 for(std::size_t j=0;j<allFMTSLeavesPerTimeSeries.size();j++)
1184 allFMTSLeavesPerTimeSeriesSafe[j].resize(allFMTSLeavesPerTimeSeries[j].size());
1185 for(std::size_t k=0;k<allFMTSLeavesPerTimeSeries[j].size();k++)
1187 allFMTSLeavesPerTimeSeries[j][k]->incrRef();//because MEDFileAnyTypeFieldMultiTS::SplitIntoCommonTimeSeries do not increments the counter
1188 allFMTSLeavesPerTimeSeriesSafe[j][k]=allFMTSLeavesPerTimeSeries[j][k];
1191 // end of memory safety part
1192 // 1st : timesteps, 2nd : meshName, 3rd : common support
1193 this->_data_structure.resize(allFMTSLeavesPerTimeSeriesSafe.size());
1194 for(std::size_t i=0;i<allFMTSLeavesPerTimeSeriesSafe.size();i++)
1196 vtksys_stl::vector< vtksys_stl::string > meshNamesLoc;
1197 std::vector< std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> > > splitByMeshName;
1198 for(std::size_t j=0;j<allFMTSLeavesPerTimeSeriesSafe[i].size();j++)
1200 std::string meshName(allFMTSLeavesPerTimeSeriesSafe[i][j]->getMeshName());
1201 vtksys_stl::vector< vtksys_stl::string >::iterator it(std::find(meshNamesLoc.begin(),meshNamesLoc.end(),meshName));
1202 if(it==meshNamesLoc.end())
1204 meshNamesLoc.push_back(meshName);
1205 splitByMeshName.resize(splitByMeshName.size()+1);
1206 splitByMeshName.back().push_back(allFMTSLeavesPerTimeSeriesSafe[i][j]);
1209 splitByMeshName[std::distance(meshNamesLoc.begin(),it)].push_back(allFMTSLeavesPerTimeSeriesSafe[i][j]);
1211 _data_structure[i].resize(meshNamesLoc.size());
1212 for(std::size_t j=0;j<splitByMeshName.size();j++)
1214 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFastCellSupportComparator> > fsp;
1215 std::vector< MEDFileAnyTypeFieldMultiTS *> sbmn(splitByMeshName[j].size());
1216 for(std::size_t k=0;k<splitByMeshName[j].size();k++)
1217 sbmn[k]=splitByMeshName[j][k];
1218 //getMeshWithName does not return a newly allocated object ! It is a true get* method !
1219 std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > commonSupSplit(MEDFileAnyTypeFieldMultiTS::SplitPerCommonSupport(sbmn,_ms->getMeshWithName(meshNamesLoc[j].c_str()),fsp));
1220 std::vector< std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> > > commonSupSplitSafe(commonSupSplit.size());
1221 this->_data_structure[i][j].resize(commonSupSplit.size());
1222 for(std::size_t k=0;k<commonSupSplit.size();k++)
1224 commonSupSplitSafe[k].resize(commonSupSplit[k].size());
1225 for(std::size_t l=0;l<commonSupSplit[k].size();l++)
1227 commonSupSplit[k][l]->incrRef();//because MEDFileAnyTypeFieldMultiTS::SplitPerCommonSupport does not increment pointers !
1228 commonSupSplitSafe[k][l]=commonSupSplit[k][l];
1231 for(std::size_t k=0;k<commonSupSplit.size();k++)
1232 this->_data_structure[i][j][k]=MEDFileFieldRepresentationLeaves(commonSupSplitSafe[k],fsp[k]);
1235 this->removeEmptyLeaves();
1237 this->computeFullNameInLeaves();
1240 void MEDFileFieldRepresentationTree::removeEmptyLeaves()
1242 std::vector< std::vector< std::vector< MEDFileFieldRepresentationLeaves > > > newSD;
1243 for(std::vector< std::vector< std::vector< MEDFileFieldRepresentationLeaves > > >::const_iterator it0=_data_structure.begin();it0!=_data_structure.end();it0++)
1245 std::vector< std::vector< MEDFileFieldRepresentationLeaves > > newSD0;
1246 for(std::vector< std::vector< MEDFileFieldRepresentationLeaves > >::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++)
1248 std::vector< MEDFileFieldRepresentationLeaves > newSD1;
1249 for(std::vector< MEDFileFieldRepresentationLeaves >::const_iterator it2=(*it1).begin();it2!=(*it1).end();it2++)
1251 newSD1.push_back(*it2);
1253 newSD0.push_back(newSD1);
1256 newSD.push_back(newSD0);
1260 bool MEDFileFieldRepresentationTree::IsFieldMeshRegardingInfo(const std::vector<std::string>& compInfos)
1262 if(compInfos.size()!=1)
1264 return compInfos[0]==COMPO_STR_TO_LOCATE_MESH_DA;
1267 std::string MEDFileFieldRepresentationTree::getDftMeshName() const
1269 return _data_structure[0][0][0].getMeshName();
1272 std::vector<double> MEDFileFieldRepresentationTree::getTimeSteps(int& lev0, const TimeKeeper& tk) const
1275 const MEDFileFieldRepresentationLeaves& leaf(getTheSingleActivated(lev0,lev1,lev2));
1276 return leaf.getTimeSteps(tk);
1279 vtkDataSet *MEDFileFieldRepresentationTree::buildVTKInstance(bool isStdOrMode, double timeReq, std::string& meshName, const TimeKeeper& tk) const
1282 const MEDFileFieldRepresentationLeaves& leaf(getTheSingleActivated(lev0,lev1,lev2));
1283 meshName=leaf.getMeshName();
1284 std::vector<double> ts(leaf.getTimeSteps(tk));
1285 std::size_t zeTimeId(0);
1288 std::vector<double> ts2(ts.size());
1289 std::transform(ts.begin(),ts.end(),ts2.begin(),std::bind2nd(std::plus<double>(),-timeReq));
1290 std::transform(ts2.begin(),ts2.end(),ts2.begin(),std::ptr_fun<double,double>(fabs));
1291 zeTimeId=std::distance(ts2.begin(),std::find_if(ts2.begin(),ts2.end(),std::bind2nd(std::less<double>(),1e-14)));
1294 if(zeTimeId==(int)ts.size())
1295 zeTimeId=std::distance(ts.begin(),std::find(ts.begin(),ts.end(),timeReq));
1296 if(zeTimeId==(int)ts.size())
1297 {//OK the time requested does not fit time series given to ParaView. It is typically the case if more than one MEDReader instance are created or TimeInspector in real time mode.
1298 //In this case the default behaviour is taken. Keep the highest time step in this lower than timeReq.
1300 double valAttachedToPos(-std::numeric_limits<double>::max());
1301 for(std::size_t i=0;i<ts.size();i++)
1305 if(ts[i]>valAttachedToPos)
1308 valAttachedToPos=ts[i];
1313 {// timeReq is lower than all time steps (ts). So let's keep the lowest time step greater than timeReq.
1314 valAttachedToPos=std::numeric_limits<double>::max();
1315 for(std::size_t i=0;i<ts.size();i++)
1317 if(ts[i]<valAttachedToPos)
1320 valAttachedToPos=ts[i];
1325 std::ostringstream oss; oss.precision(15); oss << "request for time " << timeReq << " but not in ";
1326 std::copy(ts.begin(),ts.end(),std::ostream_iterator<double>(oss,","));
1327 oss << " ! Keep time " << valAttachedToPos << " at pos #" << zeTimeId;
1328 std::cerr << oss.str() << std::endl;
1332 tr=new MEDStdTimeReq((int)zeTimeId);
1334 tr=new MEDModeTimeReq(tk.getTheVectOfBool(),tk.getPostProcessedTime());
1335 vtkDataSet *ret(leaf.buildVTKInstanceNoTimeInterpolation(tr,_fields,_ms));
1340 const MEDFileFieldRepresentationLeaves& MEDFileFieldRepresentationTree::getTheSingleActivated(int& lev0, int& lev1, int& lev2) const
1342 int nbOfActivated(0);
1343 for(std::vector< std::vector< std::vector< MEDFileFieldRepresentationLeaves > > >::const_iterator it0=_data_structure.begin();it0!=_data_structure.end();it0++)
1344 for(std::vector< std::vector< MEDFileFieldRepresentationLeaves > >::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++)
1345 for(std::vector< MEDFileFieldRepresentationLeaves >::const_iterator it2=(*it1).begin();it2!=(*it1).end();it2++)
1346 if((*it2).isActivated())
1348 if(nbOfActivated!=1)
1350 std::ostringstream oss; oss << "MEDFileFieldRepresentationTree::getTheSingleActivated : Only one leaf must be activated ! Having " << nbOfActivated << " !";
1351 throw INTERP_KERNEL::Exception(oss.str().c_str());
1353 int i0(0),i1(0),i2(0);
1354 for(std::vector< std::vector< std::vector< MEDFileFieldRepresentationLeaves > > >::const_iterator it0=_data_structure.begin();it0!=_data_structure.end();it0++,i0++)
1355 for(std::vector< std::vector< MEDFileFieldRepresentationLeaves > >::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++,i1++)
1356 for(std::vector< MEDFileFieldRepresentationLeaves >::const_iterator it2=(*it1).begin();it2!=(*it1).end();it2++,i2++)
1357 if((*it2).isActivated())
1359 lev0=i0; lev1=i1; lev2=i2;
1362 throw INTERP_KERNEL::Exception("MEDFileFieldRepresentationTree::getTheSingleActivated : Internal error !");
1365 void MEDFileFieldRepresentationTree::printMySelf(std::ostream& os) const
1368 os << "#############################################" << std::endl;
1369 for(std::vector< std::vector< std::vector< MEDFileFieldRepresentationLeaves > > >::const_iterator it0=_data_structure.begin();it0!=_data_structure.end();it0++,i++)
1372 os << "TS" << i << std::endl;
1373 for(std::vector< std::vector< MEDFileFieldRepresentationLeaves > >::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++,j++)
1376 for(std::vector< MEDFileFieldRepresentationLeaves >::const_iterator it2=(*it1).begin();it2!=(*it1).end();it2++,k++)
1379 os << " " << (*it2).getMeshName() << std::endl;
1380 os << " Comp" << k << std::endl;
1381 (*it2).printMySelf(os);
1385 os << "$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$" << std::endl;
1388 void MEDFileFieldRepresentationTree::AppendFieldFromMeshes(const ParaMEDMEM::MEDFileMeshes *ms, ParaMEDMEM::MEDFileFields *ret)
1390 for(int i=0;i<ms->getNumberOfMeshes();i++)
1392 MEDFileMesh *mm(ms->getMeshAtPos(i));
1393 std::vector<int> levs(mm->getNonEmptyLevels());
1394 ParaMEDMEM::MEDCouplingAutoRefCountObjectPtr<ParaMEDMEM::MEDFileField1TS> f1tsMultiLev(ParaMEDMEM::MEDFileField1TS::New());
1395 MEDFileUMesh *mmu(dynamic_cast<MEDFileUMesh *>(mm));
1398 for(std::vector<int>::const_iterator it=levs.begin();it!=levs.end();it++)
1400 std::vector<INTERP_KERNEL::NormalizedCellType> gts(mmu->getGeoTypesAtLevel(*it));
1401 for(std::vector<INTERP_KERNEL::NormalizedCellType>::const_iterator gt=gts.begin();gt!=gts.end();gt++)
1403 ParaMEDMEM::MEDCouplingMesh *m(mmu->getDirectUndergroundSingleGeoTypeMesh(*gt));
1404 ParaMEDMEM::MEDCouplingAutoRefCountObjectPtr<ParaMEDMEM::MEDCouplingFieldDouble> f(ParaMEDMEM::MEDCouplingFieldDouble::New(ParaMEDMEM::ON_CELLS));
1406 ParaMEDMEM::MEDCouplingAutoRefCountObjectPtr<ParaMEDMEM::DataArrayDouble> arr(ParaMEDMEM::DataArrayDouble::New()); arr->alloc(f->getNumberOfTuplesExpected());
1407 arr->setInfoOnComponent(0,std::string(COMPO_STR_TO_LOCATE_MESH_DA));
1410 f->setName(mm->getName());
1411 f1tsMultiLev->setFieldNoProfileSBT(f);
1416 std::vector<int> levsExt(mm->getNonEmptyLevelsExt());
1417 if(levsExt.size()==levs.size()+1)
1419 ParaMEDMEM::MEDCouplingAutoRefCountObjectPtr<ParaMEDMEM::MEDCouplingMesh> m(mm->getGenMeshAtLevel(1));
1420 ParaMEDMEM::MEDCouplingAutoRefCountObjectPtr<ParaMEDMEM::MEDCouplingFieldDouble> f(ParaMEDMEM::MEDCouplingFieldDouble::New(ParaMEDMEM::ON_NODES));
1422 ParaMEDMEM::MEDCouplingAutoRefCountObjectPtr<ParaMEDMEM::DataArrayDouble> arr(ParaMEDMEM::DataArrayDouble::New()); arr->alloc(m->getNumberOfNodes());
1423 arr->setInfoOnComponent(0,std::string(COMPO_STR_TO_LOCATE_MESH_DA));
1424 arr->iota(); f->setArray(arr);
1425 f->setName(mm->getName());
1426 f1tsMultiLev->setFieldNoProfileSBT(f);
1434 ParaMEDMEM::MEDCouplingAutoRefCountObjectPtr<ParaMEDMEM::MEDCouplingMesh> m(mm->getGenMeshAtLevel(0));
1435 ParaMEDMEM::MEDCouplingAutoRefCountObjectPtr<ParaMEDMEM::MEDCouplingFieldDouble> f(ParaMEDMEM::MEDCouplingFieldDouble::New(ParaMEDMEM::ON_CELLS));
1437 ParaMEDMEM::MEDCouplingAutoRefCountObjectPtr<ParaMEDMEM::DataArrayDouble> arr(ParaMEDMEM::DataArrayDouble::New()); arr->alloc(f->getNumberOfTuplesExpected());
1438 arr->setInfoOnComponent(0,std::string(COMPO_STR_TO_LOCATE_MESH_DA));
1441 f->setName(mm->getName());
1442 f1tsMultiLev->setFieldNoProfileSBT(f);
1445 ParaMEDMEM::MEDCouplingAutoRefCountObjectPtr<ParaMEDMEM::MEDFileFieldMultiTS> fmtsMultiLev(ParaMEDMEM::MEDFileFieldMultiTS::New());
1446 fmtsMultiLev->pushBackTimeStep(f1tsMultiLev);
1447 ret->pushField(fmtsMultiLev);
1451 ParaMEDMEM::MEDFileFields *MEDFileFieldRepresentationTree::BuildFieldFromMeshes(const ParaMEDMEM::MEDFileMeshes *ms)
1453 ParaMEDMEM::MEDCouplingAutoRefCountObjectPtr<ParaMEDMEM::MEDFileFields> ret(ParaMEDMEM::MEDFileFields::New());
1454 AppendFieldFromMeshes(ms,ret);
1458 std::vector<std::string> MEDFileFieldRepresentationTree::SplitFieldNameIntoParts(const std::string& fullFieldName, char sep)
1460 std::vector<std::string> ret;
1462 while(pos!=std::string::npos)
1464 std::size_t curPos(fullFieldName.find_first_of(sep,pos));
1465 std::string elt(fullFieldName.substr(pos,curPos!=std::string::npos?curPos-pos:std::string::npos));
1467 pos=fullFieldName.find_first_not_of(sep,curPos);
1473 * Here the non regression tests.
1474 * const char inp0[]="";
1475 * const char exp0[]="";
1476 * const char inp1[]="field";
1477 * const char exp1[]="field";
1478 * const char inp2[]="_________";
1479 * const char exp2[]="_________";
1480 * const char inp3[]="field_p";
1481 * const char exp3[]="field_p";
1482 * const char inp4[]="field__p";
1483 * const char exp4[]="field_p";
1484 * const char inp5[]="field_p__";
1485 * const char exp5[]="field_p";
1486 * const char inp6[]="field_p_";
1487 * const char exp6[]="field_p";
1488 * const char inp7[]="field_____EDFGEG//sdkjf_____PP_______________";
1489 * const char exp7[]="field_EDFGEG//sdkjf_PP";
1490 * const char inp8[]="field_____EDFGEG//sdkjf_____PP";
1491 * const char exp8[]="field_EDFGEG//sdkjf_PP";
1492 * const char inp9[]="_field_____EDFGEG//sdkjf_____PP_______________";
1493 * const char exp9[]="field_EDFGEG//sdkjf_PP";
1494 * const char inp10[]="___field_____EDFGEG//sdkjf_____PP_______________";
1495 * const char exp10[]="field_EDFGEG//sdkjf_PP";
1497 std::string MEDFileFieldRepresentationTree::PostProcessFieldName(const std::string& fullFieldName)
1499 static const char SEP('_');
1500 std::vector<std::string> v(SplitFieldNameIntoParts(fullFieldName,SEP));
1502 return fullFieldName;//should never happen
1506 return fullFieldName;
1510 std::string ret(v[0]);
1511 for(std::size_t i=1;i<v.size();i++)
1516 { ret+=SEP; ret+=v[i]; }
1522 return fullFieldName;
1528 TimeKeeper::TimeKeeper(int policy):_policy(policy)
1532 std::vector<double> TimeKeeper::getTimeStepsRegardingPolicy(const std::vector< std::pair<int,int> >& tsPairs, const std::vector<double>& ts) const
1537 return getTimeStepsRegardingPolicy0(tsPairs,ts);
1539 return getTimeStepsRegardingPolicy0(tsPairs,ts);
1541 throw INTERP_KERNEL::Exception("TimeKeeper::getTimeStepsRegardingPolicy : only policy 0 and 1 supported presently !");
1547 * if all of ts are in -1e299,1e299 and different each other pairs are ignored ts taken directly.
1548 * if all of ts are in -1e299,1e299 but some are not different each other ts are ignored pairs used
1549 * if some of ts are out of -1e299,1e299 ts are ignored pairs used
1551 std::vector<double> TimeKeeper::getTimeStepsRegardingPolicy0(const std::vector< std::pair<int,int> >& tsPairs, const std::vector<double>& ts) const
1553 std::size_t sz(ts.size());
1554 bool isInHumanRange(true);
1556 for(std::size_t i=0;i<sz;i++)
1559 if(ts[i]<=-1e299 || ts[i]>=1e299)
1560 isInHumanRange=false;
1563 return processedUsingPairOfIds(tsPairs);
1565 return processedUsingPairOfIds(tsPairs);
1566 _postprocessed_time=ts;
1567 return getPostProcessedTime();
1572 * idem than 0, except that ts is preaccumulated before invoking policy 0.
1574 std::vector<double> TimeKeeper::getTimeStepsRegardingPolicy1(const std::vector< std::pair<int,int> >& tsPairs, const std::vector<double>& ts) const
1576 std::size_t sz(ts.size());
1577 std::vector<double> ts2(sz);
1579 for(std::size_t i=0;i<sz;i++)
1584 return getTimeStepsRegardingPolicy0(tsPairs,ts2);
1587 int TimeKeeper::getTimeStepIdFrom(double timeReq) const
1589 std::size_t pos(std::distance(_postprocessed_time.begin(),std::find(_postprocessed_time.begin(),_postprocessed_time.end(),timeReq)));
1593 void TimeKeeper::printSelf(std::ostream& oss) const
1595 std::size_t sz(_activated_ts.size());
1596 for(std::size_t i=0;i<sz;i++)
1598 oss << "(" << i << "," << _activated_ts[i].first << "), ";
1602 std::vector<bool> TimeKeeper::getTheVectOfBool() const
1604 std::size_t sz(_activated_ts.size());
1605 std::vector<bool> ret(sz);
1606 for(std::size_t i=0;i<sz;i++)
1608 ret[i]=_activated_ts[i].first;
1613 std::vector<double> TimeKeeper::processedUsingPairOfIds(const std::vector< std::pair<int,int> >& tsPairs) const
1615 std::size_t sz(tsPairs.size());
1616 std::set<int> s0,s1;
1617 for(std::size_t i=0;i<sz;i++)
1618 { s0.insert(tsPairs[i].first); s1.insert(tsPairs[i].second); }
1621 _postprocessed_time.resize(sz);
1622 for(std::size_t i=0;i<sz;i++)
1623 _postprocessed_time[i]=(double)tsPairs[i].first;
1624 return getPostProcessedTime();
1628 _postprocessed_time.resize(sz);
1629 for(std::size_t i=0;i<sz;i++)
1630 _postprocessed_time[i]=(double)tsPairs[i].second;
1631 return getPostProcessedTime();
1633 //TimeKeeper::processedUsingPairOfIds : you are not a lucky guy ! All your time steps info in MEDFile are not discriminant taken one by one !
1634 _postprocessed_time.resize(sz);
1635 for(std::size_t i=0;i<sz;i++)
1636 _postprocessed_time[i]=(double)i;
1637 return getPostProcessedTime();
1640 void TimeKeeper::setMaxNumberOfTimeSteps(int maxNumberOfTS)
1642 _activated_ts.resize(maxNumberOfTS);
1643 for(int i=0;i<maxNumberOfTS;i++)
1645 std::ostringstream oss; oss << "000" << i;
1646 _activated_ts[i]=std::pair<bool,std::string>(true,oss.str());