1 // Copyright (C) 2010-2015 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 "vtkMutableDirectedGraph.h"
55 using namespace MEDCoupling;
57 const char MEDFileFieldRepresentationLeavesArrays::ZE_SEP[]="@@][@@";
59 const char MEDFileFieldRepresentationLeavesArrays::TS_STR[]="TS";
61 const char MEDFileFieldRepresentationLeavesArrays::COM_SUP_STR[]="ComSup";
63 const char MEDFileFieldRepresentationLeavesArrays::FAMILY_ID_CELL_NAME[]="FamilyIdCell";
65 const char MEDFileFieldRepresentationLeavesArrays::NUM_ID_CELL_NAME[]="NumIdCell";
67 const char MEDFileFieldRepresentationLeavesArrays::FAMILY_ID_NODE_NAME[]="FamilyIdNode";
69 const char MEDFileFieldRepresentationLeavesArrays::NUM_ID_NODE_NAME[]="NumIdNode";
71 const char MEDFileFieldRepresentationLeavesArrays::GLOBAL_NODE_ID_NAME[]="GlobalNodeIds";// WARNING DO NOT CHANGE IT BEFORE HAVING CHECKED IN PV SOURCES !
73 const char MEDFileFieldRepresentationTree::ROOT_OF_GRPS_IN_TREE[]="zeGrps";
75 const char MEDFileFieldRepresentationTree::ROOT_OF_FAM_IDS_IN_TREE[]="zeFamIds";
77 const char MEDFileFieldRepresentationTree::COMPO_STR_TO_LOCATE_MESH_DA[]="-@?|*_";
79 vtkIdTypeArray *ELGACmp::findOrCreate(const MEDCoupling::MEDFileFieldGlobsReal *globs, const std::vector<std::string>& locsReallyUsed, vtkDoubleArray *vtkd, vtkDataSet *ds, bool& isNew) const
81 vtkIdTypeArray *try0(isExisting(locsReallyUsed,vtkd));
90 return createNew(globs,locsReallyUsed,vtkd,ds);
94 vtkIdTypeArray *ELGACmp::isExisting(const std::vector<std::string>& locsReallyUsed, vtkDoubleArray *vtkd) const
96 std::vector< std::vector<std::string> >::iterator it(std::find(_loc_names.begin(),_loc_names.end(),locsReallyUsed));
97 if(it==_loc_names.end())
99 std::size_t pos(std::distance(_loc_names.begin(),it));
100 vtkIdTypeArray *ret(_elgas[pos]);
101 vtkInformationQuadratureSchemeDefinitionVectorKey *key(vtkQuadratureSchemeDefinition::DICTIONARY());
102 for(std::vector<std::pair< vtkQuadratureSchemeDefinition *, unsigned char > >::const_iterator it=_defs[pos].begin();it!=_defs[pos].end();it++)
104 key->Set(vtkd->GetInformation(),(*it).first,(*it).second);
106 vtkd->GetInformation()->Set(vtkQuadratureSchemeDefinition::QUADRATURE_OFFSET_ARRAY_NAME(),ret->GetName());
110 vtkIdTypeArray *ELGACmp::createNew(const MEDCoupling::MEDFileFieldGlobsReal *globs, const std::vector<std::string>& locsReallyUsed, vtkDoubleArray *vtkd, vtkDataSet *ds) const
112 const int VTK_DATA_ARRAY_DELETE=vtkDataArrayTemplate<double>::VTK_DATA_ARRAY_DELETE;
113 std::vector< std::vector<std::string> > locNames(_loc_names);
114 std::vector<vtkIdTypeArray *> elgas(_elgas);
115 std::vector< std::pair< vtkQuadratureSchemeDefinition *, unsigned char > > defs;
117 std::vector< std::vector<std::string> >::const_iterator it(std::find(locNames.begin(),locNames.end(),locsReallyUsed));
118 if(it!=locNames.end())
119 throw INTERP_KERNEL::Exception("ELGACmp::createNew : Method is expected to be called after isExisting call ! Entry already exists !");
120 locNames.push_back(locsReallyUsed);
121 vtkIdTypeArray *elga(vtkIdTypeArray::New());
122 elga->SetNumberOfComponents(1);
123 vtkInformationQuadratureSchemeDefinitionVectorKey *key(vtkQuadratureSchemeDefinition::DICTIONARY());
124 std::map<unsigned char,int> m;
125 for(std::vector<std::string>::const_iterator it=locsReallyUsed.begin();it!=locsReallyUsed.end();it++)
127 vtkQuadratureSchemeDefinition *def(vtkQuadratureSchemeDefinition::New());
128 const MEDFileFieldLoc& loc(globs->getLocalization((*it).c_str()));
129 INTERP_KERNEL::NormalizedCellType ct(loc.getGeoType());
130 const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel(ct));
131 int nbGaussPt(loc.getNbOfGaussPtPerCell()),nbPtsPerCell((int)cm.getNumberOfNodes()),dimLoc(loc.getDimension());
132 // 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.
133 std::vector<double> gsCoods2(INTERP_KERNEL::GaussInfo::NormalizeCoordinatesIfNecessary(ct,dimLoc,loc.getGaussCoords()));
134 std::vector<double> refCoods2(INTERP_KERNEL::GaussInfo::NormalizeCoordinatesIfNecessary(ct,dimLoc,loc.getRefCoords()));
135 double *shape(new double[nbPtsPerCell*nbGaussPt]);
136 INTERP_KERNEL::GaussInfo calculator(ct,gsCoods2,nbGaussPt,refCoods2,nbPtsPerCell);
137 calculator.initLocalInfo();
138 const std::vector<double>& wgths(loc.getGaussWeights());
139 for(int i=0;i<nbGaussPt;i++)
141 const double *pt0(calculator.getFunctionValues(i));
142 if(ct!=INTERP_KERNEL::NORM_HEXA27)
143 std::copy(pt0,pt0+nbPtsPerCell,shape+nbPtsPerCell*i);
146 for(int j=0;j<27;j++)
147 shape[nbPtsPerCell*i+j]=pt0[MEDMeshMultiLev::HEXA27_PERM_ARRAY[j]];
150 unsigned char vtkType(MEDMeshMultiLev::PARAMEDMEM_2_VTKTYPE[ct]);
151 m[vtkType]=nbGaussPt;
152 def->Initialize(vtkType,nbPtsPerCell,nbGaussPt,shape,const_cast<double *>(&wgths[0]));
154 key->Set(elga->GetInformation(),def,vtkType);
155 key->Set(vtkd->GetInformation(),def,vtkType);
156 defs.push_back(std::pair< vtkQuadratureSchemeDefinition *, unsigned char >(def,vtkType));
159 vtkIdType ncell(ds->GetNumberOfCells());
160 int *pt(new int[ncell]),offset(0);
161 for(vtkIdType cellId=0;cellId<ncell;cellId++)
163 vtkCell *cell(ds->GetCell(cellId));
164 int delta(m[cell->GetCellType()]);
168 elga->GetInformation()->Set(MEDUtilities::ELGA(),1);
169 elga->SetVoidArray(pt,ncell,0,VTK_DATA_ARRAY_DELETE);
170 std::ostringstream oss; oss << "ELGA" << "@" << _loc_names.size();
171 std::string ossStr(oss.str());
172 elga->SetName(ossStr.c_str());
173 elga->GetInformation()->Set(vtkAbstractArray::GUI_HIDE(),1);
174 vtkd->GetInformation()->Set(vtkQuadratureSchemeDefinition::QUADRATURE_OFFSET_ARRAY_NAME(),elga->GetName());
175 elgas.push_back(elga);
179 _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 MEDCoupling::MCAuto<MEDCoupling::MEDFileAnyTypeFieldMultiTS>& arr):MEDCoupling::MCAuto<MEDCoupling::MEDFileAnyTypeFieldMultiTS>(arr),_activated(false),_id(-1)
206 std::vector< std::vector<MEDCoupling::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 MEDCoupling::MCAuto<MEDCoupling::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 MEDCoupling::MCAuto<MEDCoupling::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 MEDCoupling::MEDFileFieldGlobsReal *globs, const MEDCoupling::MEDMeshMultiLev *mml, const MEDCoupling::MEDFileMeshStruct *mst, vtkDataSet *ds) const
278 const int VTK_DATA_ARRAY_FREE=vtkDataArrayTemplate<double>::VTK_DATA_ARRAY_FREE;
279 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 MCAuto<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 MCAuto<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->SetVoidArray(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< MEDCoupling::MCAuto<MEDCoupling::MEDFileAnyTypeFieldMultiTS> >& arr,
446 const MEDCoupling::MCAuto<MEDCoupling::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 MEDCoupling::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 MEDCoupling::MEDFileMesh *m(0);
505 m=ms->getMeshWithName(meshName);
506 const MEDCoupling::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 void MEDFileFieldRepresentationLeaves::dumpState(std::map<std::string,bool>& status) const
540 for(std::vector<MEDFileFieldRepresentationLeavesArrays>::const_iterator it=_arrays.begin();it!=_arrays.end();it++)
541 status[(*it).getZeName()]=(*it).getStatus();
544 bool MEDFileFieldRepresentationLeaves::isActivated() const
546 for(std::vector<MEDFileFieldRepresentationLeavesArrays>::const_iterator it=_arrays.begin();it!=_arrays.end();it++)
547 if((*it).getStatus())
552 void MEDFileFieldRepresentationLeaves::printMySelf(std::ostream& os) const
554 for(std::vector<MEDFileFieldRepresentationLeavesArrays>::const_iterator it0=_arrays.begin();it0!=_arrays.end();it0++)
556 os << " - " << (*it0).getZeName() << " (";
557 if((*it0).getStatus())
561 os << ")" << std::endl;
565 void MEDFileFieldRepresentationLeaves::activateAllArrays() const
567 for(std::vector<MEDFileFieldRepresentationLeavesArrays>::const_iterator it=_arrays.begin();it!=_arrays.end();it++)
568 (*it).setStatus(true);
571 const MEDFileFieldRepresentationLeavesArrays& MEDFileFieldRepresentationLeaves::getLeafArr(int id) const
573 for(std::vector<MEDFileFieldRepresentationLeavesArrays>::const_iterator it=_arrays.begin();it!=_arrays.end();it++)
574 if((*it).getId()==id)
576 throw INTERP_KERNEL::Exception("MEDFileFieldRepresentationLeaves::getLeafArr ! No such id !");
579 std::vector<double> MEDFileFieldRepresentationLeaves::getTimeSteps(const TimeKeeper& tk) const
582 throw INTERP_KERNEL::Exception("MEDFileFieldRepresentationLeaves::getTimeSteps : the array size must be at least of size one !");
583 std::vector<double> ret;
584 std::vector< std::pair<int,int> > dtits(_arrays[0]->getTimeSteps(ret));
585 return tk.getTimeStepsRegardingPolicy(dtits,ret);
588 std::vector< std::pair<int,int> > MEDFileFieldRepresentationLeaves::getTimeStepsInCoarseMEDFileFormat(std::vector<double>& ts) const
591 return _arrays[0]->getTimeSteps(ts);
595 return std::vector< std::pair<int,int> >();
599 std::string MEDFileFieldRepresentationLeaves::getHumanReadableOverviewOfTS() const
601 std::ostringstream oss;
602 oss << _arrays[0]->getNumberOfTS() << " time steps [" << _arrays[0]->getDtUnit() << "]\n(";
603 std::vector<double> ret1;
604 std::vector< std::pair<int,int> > ret2(getTimeStepsInCoarseMEDFileFormat(ret1));
605 std::size_t sz(ret1.size());
606 for(std::size_t i=0;i<sz;i++)
608 oss << ret1[i] << " (" << ret2[i].first << "," << ret2[i].second << ")";
611 std::string tmp(oss.str());
612 if(tmp.size()>200 && i!=sz-1)
622 void MEDFileFieldRepresentationLeaves::appendFields(const MEDTimeReq *tr, const MEDCoupling::MEDFileFieldGlobsReal *globs, const MEDCoupling::MEDMeshMultiLev *mml, const MEDCoupling::MEDFileMeshes *meshes, vtkDataSet *ds) const
625 throw INTERP_KERNEL::Exception("MEDFileFieldRepresentationLeaves::appendFields : internal error !");
626 MCAuto<MEDFileMeshStruct> mst(MEDFileMeshStruct::New(meshes->getMeshWithName(_arrays[0]->getMeshName().c_str())));
627 for(std::vector<MEDFileFieldRepresentationLeavesArrays>::const_iterator it=_arrays.begin();it!=_arrays.end();it++)
628 if((*it).getStatus())
630 (*it).appendFields(tr,globs,mml,mst,ds);
631 (*it).appendELGAIfAny(ds);
635 vtkUnstructuredGrid *MEDFileFieldRepresentationLeaves::buildVTKInstanceNoTimeInterpolationUnstructured(MEDUMeshMultiLev *mm) const
637 const int VTK_DATA_ARRAY_FREE=vtkDataArrayTemplate<double>::VTK_DATA_ARRAY_FREE;
638 DataArrayDouble *coordsMC(0);
639 DataArrayByte *typesMC(0);
640 DataArrayInt *cellLocationsMC(0),*cellsMC(0),*faceLocationsMC(0),*facesMC(0);
641 bool statusOfCoords(mm->buildVTUArrays(coordsMC,typesMC,cellLocationsMC,cellsMC,faceLocationsMC,facesMC));
642 MCAuto<DataArrayDouble> coordsSafe(coordsMC);
643 MCAuto<DataArrayByte> typesSafe(typesMC);
644 MCAuto<DataArrayInt> cellLocationsSafe(cellLocationsMC),cellsSafe(cellsMC),faceLocationsSafe(faceLocationsMC),facesSafe(facesMC);
646 int nbOfCells(typesSafe->getNbOfElems());
647 vtkUnstructuredGrid *ret(vtkUnstructuredGrid::New());
648 vtkUnsignedCharArray *cellTypes(vtkUnsignedCharArray::New());
649 cellTypes->SetArray(reinterpret_cast<unsigned char *>(typesSafe->getPointer()),nbOfCells,0,VTK_DATA_ARRAY_FREE); typesSafe->accessToMemArray().setSpecificDeallocator(0);
650 vtkIdTypeArray *cellLocations(vtkIdTypeArray::New());
651 cellLocations->SetVoidArray(cellLocationsSafe->getPointer(),nbOfCells,0,VTK_DATA_ARRAY_FREE); cellLocationsSafe->accessToMemArray().setSpecificDeallocator(0);
652 vtkCellArray *cells(vtkCellArray::New());
653 vtkIdTypeArray *cells2(vtkIdTypeArray::New());
654 cells2->SetVoidArray(cellsSafe->getPointer(),cellsSafe->getNbOfElems(),0,VTK_DATA_ARRAY_FREE); cellsSafe->accessToMemArray().setSpecificDeallocator(0);
655 cells->SetCells(nbOfCells,cells2);
657 if(faceLocationsMC!=0 && facesMC!=0)
659 vtkIdTypeArray *faces(vtkIdTypeArray::New());
660 faces->SetVoidArray(facesSafe->getPointer(),facesSafe->getNbOfElems(),0,VTK_DATA_ARRAY_FREE); facesSafe->accessToMemArray().setSpecificDeallocator(0);
661 vtkIdTypeArray *faceLocations(vtkIdTypeArray::New());
662 faceLocations->SetVoidArray(faceLocationsSafe->getPointer(),faceLocationsSafe->getNbOfElems(),0,VTK_DATA_ARRAY_FREE); faceLocationsSafe->accessToMemArray().setSpecificDeallocator(0);
663 ret->SetCells(cellTypes,cellLocations,cells,faceLocations,faces);
664 faceLocations->Delete();
668 ret->SetCells(cellTypes,cellLocations,cells);
670 cellLocations->Delete();
672 vtkPoints *pts(vtkPoints::New());
673 vtkDoubleArray *pts2(vtkDoubleArray::New());
674 pts2->SetNumberOfComponents(3);
677 pts2->SetArray(coordsSafe->getPointer(),coordsSafe->getNbOfElems(),0,VTK_DATA_ARRAY_FREE);
678 coordsSafe->accessToMemArray().setSpecificDeallocator(0);
681 pts2->SetArray(coordsSafe->getPointer(),coordsSafe->getNbOfElems(),1,VTK_DATA_ARRAY_FREE);
690 vtkRectilinearGrid *MEDFileFieldRepresentationLeaves::buildVTKInstanceNoTimeInterpolationCartesian(MEDCoupling::MEDCMeshMultiLev *mm) const
692 const int VTK_DATA_ARRAY_FREE=vtkDataArrayTemplate<double>::VTK_DATA_ARRAY_FREE;
694 std::vector< DataArrayDouble * > arrs(mm->buildVTUArrays(isInternal));
695 vtkDoubleArray *vtkTmp(0);
696 vtkRectilinearGrid *ret(vtkRectilinearGrid::New());
697 std::size_t dim(arrs.size());
699 throw INTERP_KERNEL::Exception("buildVTKInstanceNoTimeInterpolationCartesian : dimension must be in [1,3] !");
700 int sizePerAxe[3]={1,1,1};
701 sizePerAxe[0]=arrs[0]->getNbOfElems();
703 sizePerAxe[1]=arrs[1]->getNbOfElems();
705 sizePerAxe[2]=arrs[2]->getNbOfElems();
706 ret->SetDimensions(sizePerAxe[0],sizePerAxe[1],sizePerAxe[2]);
707 vtkTmp=vtkDoubleArray::New();
708 vtkTmp->SetNumberOfComponents(1);
710 vtkTmp->SetArray(arrs[0]->getPointer(),arrs[0]->getNbOfElems(),1,VTK_DATA_ARRAY_FREE);
712 { vtkTmp->SetArray(arrs[0]->getPointer(),arrs[0]->getNbOfElems(),0,VTK_DATA_ARRAY_FREE); arrs[0]->accessToMemArray().setSpecificDeallocator(0); }
713 ret->SetXCoordinates(vtkTmp);
718 vtkTmp=vtkDoubleArray::New();
719 vtkTmp->SetNumberOfComponents(1);
721 vtkTmp->SetArray(arrs[1]->getPointer(),arrs[1]->getNbOfElems(),1,VTK_DATA_ARRAY_FREE);
723 { vtkTmp->SetArray(arrs[1]->getPointer(),arrs[1]->getNbOfElems(),0,VTK_DATA_ARRAY_FREE); arrs[1]->accessToMemArray().setSpecificDeallocator(0); }
724 ret->SetYCoordinates(vtkTmp);
730 vtkTmp=vtkDoubleArray::New();
731 vtkTmp->SetNumberOfComponents(1);
733 vtkTmp->SetArray(arrs[2]->getPointer(),arrs[2]->getNbOfElems(),1,VTK_DATA_ARRAY_FREE);
735 { vtkTmp->SetArray(arrs[2]->getPointer(),arrs[2]->getNbOfElems(),0,VTK_DATA_ARRAY_FREE); arrs[2]->accessToMemArray().setSpecificDeallocator(0); }
736 ret->SetZCoordinates(vtkTmp);
743 vtkStructuredGrid *MEDFileFieldRepresentationLeaves::buildVTKInstanceNoTimeInterpolationCurveLinear(MEDCoupling::MEDCurveLinearMeshMultiLev *mm) const
745 const int VTK_DATA_ARRAY_FREE=vtkDataArrayTemplate<double>::VTK_DATA_ARRAY_FREE;
746 int meshStr[3]={1,1,1};
747 DataArrayDouble *coords(0);
748 std::vector<int> nodeStrct;
750 mm->buildVTUArrays(coords,nodeStrct,isInternal);
751 std::size_t dim(nodeStrct.size());
753 throw INTERP_KERNEL::Exception("buildVTKInstanceNoTimeInterpolationCurveLinear : dimension must be in [1,3] !");
754 meshStr[0]=nodeStrct[0];
756 meshStr[1]=nodeStrct[1];
758 meshStr[2]=nodeStrct[2];
759 vtkStructuredGrid *ret(vtkStructuredGrid::New());
760 ret->SetDimensions(meshStr[0],meshStr[1],meshStr[2]);
761 vtkDoubleArray *da(vtkDoubleArray::New());
762 da->SetNumberOfComponents(3);
763 if(coords->getNumberOfComponents()==3)
766 da->SetArray(coords->getPointer(),coords->getNbOfElems(),1,VTK_DATA_ARRAY_FREE);//VTK has not the ownership of double * because MEDLoader main struct has it !
768 { da->SetArray(coords->getPointer(),coords->getNbOfElems(),0,VTK_DATA_ARRAY_FREE); coords->accessToMemArray().setSpecificDeallocator(0); }
772 MCAuto<DataArrayDouble> coords2(coords->changeNbOfComponents(3,0.));
773 da->SetArray(coords2->getPointer(),coords2->getNbOfElems(),0,VTK_DATA_ARRAY_FREE);//let VTK deal with double *
774 coords2->accessToMemArray().setSpecificDeallocator(0);
777 vtkPoints *points=vtkPoints::New();
778 ret->SetPoints(points);
785 vtkDataSet *MEDFileFieldRepresentationLeaves::buildVTKInstanceNoTimeInterpolation(const MEDTimeReq *tr, const MEDFileFieldGlobsReal *globs, const MEDCoupling::MEDFileMeshes *meshes) const
787 const int VTK_DATA_ARRAY_FREE=vtkDataArrayTemplate<double>::VTK_DATA_ARRAY_FREE;
789 //_fsp->isDataSetSupportEqualToThePreviousOne(i,globs);
790 MCAuto<MEDMeshMultiLev> mml(_fsp->buildFromScratchDataSetSupport(0,globs));//0=timestep Id. Make the hypothesis that support does not change
791 MCAuto<MEDMeshMultiLev> mml2(mml->prepare());
792 MEDMeshMultiLev *ptMML2(mml2);
795 MEDUMeshMultiLev *ptUMML2(dynamic_cast<MEDUMeshMultiLev *>(ptMML2));
796 MEDCMeshMultiLev *ptCMML2(dynamic_cast<MEDCMeshMultiLev *>(ptMML2));
797 MEDCurveLinearMeshMultiLev *ptCLMML2(dynamic_cast<MEDCurveLinearMeshMultiLev *>(ptMML2));
801 ret=buildVTKInstanceNoTimeInterpolationUnstructured(ptUMML2);
805 ret=buildVTKInstanceNoTimeInterpolationCartesian(ptCMML2);
809 ret=buildVTKInstanceNoTimeInterpolationCurveLinear(ptCLMML2);
812 throw INTERP_KERNEL::Exception("MEDFileFieldRepresentationLeaves::buildVTKInstanceNoTimeInterpolation : unrecognized mesh ! Supported for the moment unstructured, cartesian, curvelinear !");
813 _cached_ds=ret->NewInstance();
814 _cached_ds->ShallowCopy(ret);
818 ret=_cached_ds->NewInstance();
819 ret->ShallowCopy(_cached_ds);
822 appendFields(tr,globs,mml,meshes,ret);
823 // The arrays links to mesh
824 DataArrayInt *famCells(0),*numCells(0);
825 bool noCpyFamCells(false),noCpyNumCells(false);
826 ptMML2->retrieveFamilyIdsOnCells(famCells,noCpyFamCells);
829 vtkIntArray *vtkTab(vtkIntArray::New());
830 vtkTab->SetNumberOfComponents(1);
831 vtkTab->SetName(MEDFileFieldRepresentationLeavesArrays::FAMILY_ID_CELL_NAME);
833 vtkTab->SetArray(famCells->getPointer(),famCells->getNbOfElems(),1,VTK_DATA_ARRAY_FREE);
835 { vtkTab->SetArray(famCells->getPointer(),famCells->getNbOfElems(),0,VTK_DATA_ARRAY_FREE); famCells->accessToMemArray().setSpecificDeallocator(0); }
836 ret->GetCellData()->AddArray(vtkTab);
840 ptMML2->retrieveNumberIdsOnCells(numCells,noCpyNumCells);
843 vtkIntArray *vtkTab(vtkIntArray::New());
844 vtkTab->SetNumberOfComponents(1);
845 vtkTab->SetName(MEDFileFieldRepresentationLeavesArrays::NUM_ID_CELL_NAME);
847 vtkTab->SetArray(numCells->getPointer(),numCells->getNbOfElems(),1,VTK_DATA_ARRAY_FREE);
849 { vtkTab->SetArray(numCells->getPointer(),numCells->getNbOfElems(),0,VTK_DATA_ARRAY_FREE); numCells->accessToMemArray().setSpecificDeallocator(0); }
850 ret->GetCellData()->AddArray(vtkTab);
854 // The arrays links to mesh
855 DataArrayInt *famNodes(0),*numNodes(0);
856 bool noCpyFamNodes(false),noCpyNumNodes(false);
857 ptMML2->retrieveFamilyIdsOnNodes(famNodes,noCpyFamNodes);
860 vtkIntArray *vtkTab(vtkIntArray::New());
861 vtkTab->SetNumberOfComponents(1);
862 vtkTab->SetName(MEDFileFieldRepresentationLeavesArrays::FAMILY_ID_NODE_NAME);
864 vtkTab->SetArray(famNodes->getPointer(),famNodes->getNbOfElems(),1,VTK_DATA_ARRAY_FREE);
866 { vtkTab->SetArray(famNodes->getPointer(),famNodes->getNbOfElems(),0,VTK_DATA_ARRAY_FREE); famNodes->accessToMemArray().setSpecificDeallocator(0); }
867 ret->GetPointData()->AddArray(vtkTab);
871 ptMML2->retrieveNumberIdsOnNodes(numNodes,noCpyNumNodes);
874 vtkIntArray *vtkTab(vtkIntArray::New());
875 vtkTab->SetNumberOfComponents(1);
876 vtkTab->SetName(MEDFileFieldRepresentationLeavesArrays::NUM_ID_NODE_NAME);
878 vtkTab->SetArray(numNodes->getPointer(),numNodes->getNbOfElems(),1,VTK_DATA_ARRAY_FREE);
880 { vtkTab->SetArray(numNodes->getPointer(),numNodes->getNbOfElems(),0,VTK_DATA_ARRAY_FREE); numNodes->accessToMemArray().setSpecificDeallocator(0); }
881 ret->GetPointData()->AddArray(vtkTab);
885 // Global Node Ids if any ! (In // mode)
886 DataArrayInt *gni(ptMML2->retrieveGlobalNodeIdsIfAny());
889 vtkIntArray *vtkTab(vtkIntArray::New());
890 vtkTab->SetNumberOfComponents(1);
891 vtkTab->SetName(MEDFileFieldRepresentationLeavesArrays::GLOBAL_NODE_ID_NAME);
892 vtkTab->SetArray(gni->getPointer(),gni->getNbOfElems(),0,VTK_DATA_ARRAY_FREE);
893 gni->accessToMemArray().setSpecificDeallocator(0);
899 //////////////////////
901 MEDFileFieldRepresentationTree::MEDFileFieldRepresentationTree()
905 int MEDFileFieldRepresentationTree::getNumberOfLeavesArrays() const
908 for(std::vector< std::vector< std::vector< MEDFileFieldRepresentationLeaves > > >::const_iterator it0=_data_structure.begin();it0!=_data_structure.end();it0++)
909 for(std::vector< std::vector< MEDFileFieldRepresentationLeaves > >::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++)
910 for(std::vector< MEDFileFieldRepresentationLeaves >::const_iterator it2=(*it1).begin();it2!=(*it1).end();it2++)
911 ret+=(*it2).getNumberOfArrays();
915 void MEDFileFieldRepresentationTree::assignIds() const
918 for(std::vector< std::vector< std::vector< MEDFileFieldRepresentationLeaves > > >::const_iterator it0=_data_structure.begin();it0!=_data_structure.end();it0++)
919 for(std::vector< std::vector< MEDFileFieldRepresentationLeaves > >::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++)
920 for(std::vector< MEDFileFieldRepresentationLeaves >::const_iterator it2=(*it1).begin();it2!=(*it1).end();it2++)
924 void MEDFileFieldRepresentationTree::computeFullNameInLeaves() const
926 std::size_t it0Cnt(0);
927 for(std::vector< std::vector< std::vector< MEDFileFieldRepresentationLeaves > > >::const_iterator it0=_data_structure.begin();it0!=_data_structure.end();it0++,it0Cnt++)
929 std::ostringstream oss; oss << MEDFileFieldRepresentationLeavesArrays::TS_STR << it0Cnt;
930 std::string tsName(oss.str());
931 for(std::vector< std::vector< MEDFileFieldRepresentationLeaves > >::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++)
933 std::string meshName((*it1)[0].getMeshName());
934 std::size_t it2Cnt(0);
935 for(std::vector< MEDFileFieldRepresentationLeaves >::const_iterator it2=(*it1).begin();it2!=(*it1).end();it2++,it2Cnt++)
937 std::ostringstream oss2; oss2 << MEDFileFieldRepresentationLeavesArrays::COM_SUP_STR << it2Cnt;
938 std::string comSupStr(oss2.str());
939 (*it2).computeFullNameInLeaves(tsName,meshName,comSupStr);
945 void MEDFileFieldRepresentationTree::activateTheFirst() const
947 for(std::vector< std::vector< std::vector< MEDFileFieldRepresentationLeaves > > >::const_iterator it0=_data_structure.begin();it0!=_data_structure.end();it0++)
948 for(std::vector< std::vector< MEDFileFieldRepresentationLeaves > >::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++)
949 for(std::vector< MEDFileFieldRepresentationLeaves >::const_iterator it2=(*it1).begin();it2!=(*it1).end();it2++)
951 (*it2).activateAllArrays();
956 void MEDFileFieldRepresentationTree::feedSIL(vtkMutableDirectedGraph* sil, vtkIdType root, vtkVariantArray *edge, std::vector<std::string>& names) const
958 std::size_t it0Cnt(0);
959 for(std::vector< std::vector< std::vector< MEDFileFieldRepresentationLeaves > > >::const_iterator it0=_data_structure.begin();it0!=_data_structure.end();it0++,it0Cnt++)
961 vtkIdType InfoOnTSId(sil->AddChild(root,edge));
962 names.push_back((*it0)[0][0].getHumanReadableOverviewOfTS());
964 vtkIdType NbOfTSId(sil->AddChild(InfoOnTSId,edge));
965 std::vector<double> ts;
966 std::vector< std::pair<int,int> > dtits((*it0)[0][0].getTimeStepsInCoarseMEDFileFormat(ts));
967 std::size_t nbOfTS(dtits.size());
968 std::ostringstream oss3; oss3 << nbOfTS;
969 names.push_back(oss3.str());
970 for(std::size_t i=0;i<nbOfTS;i++)
972 std::ostringstream oss4; oss4 << dtits[i].first;
973 vtkIdType DtId(sil->AddChild(NbOfTSId,edge));
974 names.push_back(oss4.str());
975 std::ostringstream oss5; oss5 << dtits[i].second;
976 vtkIdType ItId(sil->AddChild(DtId,edge));
977 names.push_back(oss5.str());
978 std::ostringstream oss6; oss6 << ts[i];
979 sil->AddChild(ItId,edge);
980 names.push_back(oss6.str());
983 std::ostringstream oss; oss << MEDFileFieldRepresentationLeavesArrays::TS_STR << it0Cnt;
984 std::string tsName(oss.str());
985 vtkIdType typeId0(sil->AddChild(root,edge));
986 names.push_back(tsName);
987 for(std::vector< std::vector< MEDFileFieldRepresentationLeaves > >::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++)
989 std::string meshName((*it1)[0].getMeshName());
990 vtkIdType typeId1(sil->AddChild(typeId0,edge));
991 names.push_back(meshName);
992 std::size_t it2Cnt(0);
993 for(std::vector< MEDFileFieldRepresentationLeaves >::const_iterator it2=(*it1).begin();it2!=(*it1).end();it2++,it2Cnt++)
995 std::ostringstream oss2; oss2 << MEDFileFieldRepresentationLeavesArrays::COM_SUP_STR << it2Cnt;
996 std::string comSupStr(oss2.str());
997 vtkIdType typeId2(sil->AddChild(typeId1,edge));
998 names.push_back(comSupStr);
999 (*it2).feedSIL(_ms,meshName,sil,typeId2,edge,names);
1005 std::string MEDFileFieldRepresentationTree::feedSILForFamsAndGrps(vtkMutableDirectedGraph* sil, vtkIdType root, vtkVariantArray *edge, std::vector<std::string>& names) const
1007 int dummy0(0),dummy1(0),dummy2(0);
1008 const MEDFileFieldRepresentationLeaves& leaf(getTheSingleActivated(dummy0,dummy1,dummy2));
1009 std::string ret(leaf.getMeshName());
1012 for(;i<_ms->getNumberOfMeshes();i++)
1014 m=_ms->getMeshAtPos(i);
1015 if(m->getName()==ret)
1018 if(i==_ms->getNumberOfMeshes())
1019 throw INTERP_KERNEL::Exception("MEDFileFieldRepresentationTree::feedSILForFamsAndGrps : internal error #0 !");
1020 vtkIdType typeId0(sil->AddChild(root,edge));
1021 names.push_back(m->getName());
1023 vtkIdType typeId1(sil->AddChild(typeId0,edge));
1024 names.push_back(std::string(ROOT_OF_GRPS_IN_TREE));
1025 std::vector<std::string> grps(m->getGroupsNames());
1026 for(std::vector<std::string>::const_iterator it0=grps.begin();it0!=grps.end();it0++)
1028 vtkIdType typeId2(sil->AddChild(typeId1,edge));
1029 names.push_back(*it0);
1030 std::vector<std::string> famsOnGrp(m->getFamiliesOnGroup((*it0).c_str()));
1031 for(std::vector<std::string>::const_iterator it1=famsOnGrp.begin();it1!=famsOnGrp.end();it1++)
1033 sil->AddChild(typeId2,edge);
1034 names.push_back((*it1).c_str());
1038 vtkIdType typeId11(sil->AddChild(typeId0,edge));
1039 names.push_back(std::string(ROOT_OF_FAM_IDS_IN_TREE));
1040 std::vector<std::string> fams(m->getFamiliesNames());
1041 for(std::vector<std::string>::const_iterator it00=fams.begin();it00!=fams.end();it00++)
1043 sil->AddChild(typeId11,edge);
1044 int famId(m->getFamilyId((*it00).c_str()));
1045 std::ostringstream oss; oss << (*it00) << MEDFileFieldRepresentationLeavesArrays::ZE_SEP << famId;
1046 names.push_back(oss.str());
1051 const MEDFileFieldRepresentationLeavesArrays& MEDFileFieldRepresentationTree::getLeafArr(int id) const
1053 for(std::vector< std::vector< std::vector< MEDFileFieldRepresentationLeaves > > >::const_iterator it0=_data_structure.begin();it0!=_data_structure.end();it0++)
1054 for(std::vector< std::vector< MEDFileFieldRepresentationLeaves > >::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++)
1055 for(std::vector< MEDFileFieldRepresentationLeaves >::const_iterator it2=(*it1).begin();it2!=(*it1).end();it2++)
1056 if((*it2).containId(id))
1057 return (*it2).getLeafArr(id);
1058 throw INTERP_KERNEL::Exception("Internal error in MEDFileFieldRepresentationTree::getLeafArr !");
1061 std::string MEDFileFieldRepresentationTree::getNameOf(int id) const
1063 const MEDFileFieldRepresentationLeavesArrays& elt(getLeafArr(id));
1064 return elt.getZeName();
1067 const char *MEDFileFieldRepresentationTree::getNameOfC(int id) const
1069 const MEDFileFieldRepresentationLeavesArrays& elt(getLeafArr(id));
1070 return elt.getZeNameC();
1073 bool MEDFileFieldRepresentationTree::getStatusOf(int id) const
1075 const MEDFileFieldRepresentationLeavesArrays& elt(getLeafArr(id));
1076 return elt.getStatus();
1079 int MEDFileFieldRepresentationTree::getIdHavingZeName(const char *name) const
1082 for(std::vector< std::vector< std::vector< MEDFileFieldRepresentationLeaves > > >::const_iterator it0=_data_structure.begin();it0!=_data_structure.end();it0++)
1083 for(std::vector< std::vector< MEDFileFieldRepresentationLeaves > >::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++)
1084 for(std::vector< MEDFileFieldRepresentationLeaves >::const_iterator it2=(*it1).begin();it2!=(*it1).end();it2++)
1085 if((*it2).containZeName(name,ret))
1087 std::ostringstream msg; msg << "MEDFileFieldRepresentationTree::getIdHavingZeName : No such a name \"" << name << "\" !";
1088 throw INTERP_KERNEL::Exception(msg.str().c_str());
1091 bool MEDFileFieldRepresentationTree::changeStatusOfAndUpdateToHaveCoherentVTKDataSet(int id, bool status) const
1093 const MEDFileFieldRepresentationLeavesArrays& elt(getLeafArr(id));
1094 bool ret(elt.setStatus(status));//to be implemented
1098 int MEDFileFieldRepresentationTree::getMaxNumberOfTimeSteps() const
1101 for(std::vector< std::vector< std::vector< MEDFileFieldRepresentationLeaves > > >::const_iterator it0=_data_structure.begin();it0!=_data_structure.end();it0++)
1102 for(std::vector< std::vector< MEDFileFieldRepresentationLeaves > >::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++)
1103 for(std::vector< MEDFileFieldRepresentationLeaves >::const_iterator it2=(*it1).begin();it2!=(*it1).end();it2++)
1104 ret=std::max(ret,(*it2).getNumberOfTS());
1111 void MEDFileFieldRepresentationTree::loadMainStructureOfFile(const char *fileName, bool isMEDOrSauv, int iPart, int nbOfParts)
1115 if((iPart==-1 && nbOfParts==-1) || (iPart==0 && nbOfParts==1))
1117 _ms=MEDFileMeshes::New(fileName);
1118 _fields=MEDFileFields::New(fileName,false);//false is important to not read the values
1122 #ifdef MEDREADER_USE_MPI
1123 _ms=ParaMEDFileMeshes::New(iPart,nbOfParts,fileName);
1124 int nbMeshes(_ms->getNumberOfMeshes());
1125 for(int i=0;i<nbMeshes;i++)
1127 MEDCoupling::MEDFileMesh *tmp(_ms->getMeshAtPos(i));
1128 MEDCoupling::MEDFileUMesh *tmp2(dynamic_cast<MEDCoupling::MEDFileUMesh *>(tmp));
1130 MCAuto<DataArrayInt> tmp3(tmp2->zipCoords());
1132 _fields=MEDFileFields::LoadPartOf(fileName,false,_ms);//false is important to not read the values
1134 std::ostringstream oss; oss << "MEDFileFieldRepresentationTree::loadMainStructureOfFile : request for iPart/nbOfParts=" << iPart << "/" << nbOfParts << " whereas Plugin not compiled with MPI !";
1135 throw INTERP_KERNEL::Exception(oss.str().c_str());
1141 MCAuto<MEDCoupling::SauvReader> sr(MEDCoupling::SauvReader::New(fileName));
1142 MCAuto<MEDCoupling::MEDFileData> mfd(sr->loadInMEDFileDS());
1143 _ms=mfd->getMeshes(); _ms->incrRef();
1144 int nbMeshes(_ms->getNumberOfMeshes());
1145 for(int i=0;i<nbMeshes;i++)
1147 MEDCoupling::MEDFileMesh *tmp(_ms->getMeshAtPos(i));
1148 MEDCoupling::MEDFileUMesh *tmp2(dynamic_cast<MEDCoupling::MEDFileUMesh *>(tmp));
1150 tmp2->forceComputationOfParts();
1152 _fields=mfd->getFields();
1153 if((MEDCoupling::MEDFileFields *)_fields)
1156 if(!((MEDCoupling::MEDFileFields *)_fields))
1158 _fields=BuildFieldFromMeshes(_ms);
1162 AppendFieldFromMeshes(_ms,_fields);
1164 _ms->cartesianizeMe();
1165 _fields->removeFieldsWithoutAnyTimeStep();
1166 std::vector<std::string> meshNames(_ms->getMeshesNames());
1167 std::vector< MCAuto<MEDFileFields> > fields_per_mesh(meshNames.size());
1168 for(std::size_t i=0;i<meshNames.size();i++)
1170 fields_per_mesh[i]=_fields->partOfThisLyingOnSpecifiedMeshName(meshNames[i].c_str());
1172 std::vector< MCAuto<MEDFileAnyTypeFieldMultiTS > > allFMTSLeavesToDisplaySafe;
1174 for(std::vector< MCAuto<MEDFileFields> >::const_iterator fields=fields_per_mesh.begin();fields!=fields_per_mesh.end();fields++)
1176 for(int j=0;j<(*fields)->getNumberOfFields();j++)
1178 MCAuto<MEDFileAnyTypeFieldMultiTS> fmts((*fields)->getFieldAtPos((int)j));
1179 std::vector< MCAuto< MEDFileAnyTypeFieldMultiTS > > tmp(fmts->splitDiscretizations());
1181 for(std::vector< MCAuto< MEDFileAnyTypeFieldMultiTS > >::const_iterator it=tmp.begin();it!=tmp.end();it++)
1183 if(!(*it)->presenceOfMultiDiscPerGeoType())
1184 allFMTSLeavesToDisplaySafe.push_back(*it);
1186 {// The case of some parts of field have more than one discretization per geo type.
1187 std::vector< MCAuto< MEDFileAnyTypeFieldMultiTS > > subTmp((*it)->splitMultiDiscrPerGeoTypes());
1188 std::size_t it0Cnt(0);
1189 for(std::vector< MCAuto< MEDFileAnyTypeFieldMultiTS > >::iterator it0=subTmp.begin();it0!=subTmp.end();it0++,it0Cnt++)//not const because setName
1191 std::ostringstream oss; oss << (*it0)->getName() << "_" << std::setfill('M') << std::setw(3) << it0Cnt;
1192 (*it0)->setName(oss.str());
1193 allFMTSLeavesToDisplaySafe.push_back(*it0);
1200 std::vector< MEDFileAnyTypeFieldMultiTS *> allFMTSLeavesToDisplay(allFMTSLeavesToDisplaySafe.size());
1201 for(std::size_t i=0;i<allFMTSLeavesToDisplaySafe.size();i++)
1203 allFMTSLeavesToDisplay[i]=allFMTSLeavesToDisplaySafe[i];
1205 std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > allFMTSLeavesPerTimeSeries(MEDFileAnyTypeFieldMultiTS::SplitIntoCommonTimeSeries(allFMTSLeavesToDisplay));
1206 // memory safety part
1207 std::vector< std::vector< MCAuto<MEDFileAnyTypeFieldMultiTS> > > allFMTSLeavesPerTimeSeriesSafe(allFMTSLeavesPerTimeSeries.size());
1208 for(std::size_t j=0;j<allFMTSLeavesPerTimeSeries.size();j++)
1210 allFMTSLeavesPerTimeSeriesSafe[j].resize(allFMTSLeavesPerTimeSeries[j].size());
1211 for(std::size_t k=0;k<allFMTSLeavesPerTimeSeries[j].size();k++)
1213 allFMTSLeavesPerTimeSeries[j][k]->incrRef();//because MEDFileAnyTypeFieldMultiTS::SplitIntoCommonTimeSeries do not increments the counter
1214 allFMTSLeavesPerTimeSeriesSafe[j][k]=allFMTSLeavesPerTimeSeries[j][k];
1217 // end of memory safety part
1218 // 1st : timesteps, 2nd : meshName, 3rd : common support
1219 this->_data_structure.resize(allFMTSLeavesPerTimeSeriesSafe.size());
1220 for(std::size_t i=0;i<allFMTSLeavesPerTimeSeriesSafe.size();i++)
1222 std::vector< std::string > meshNamesLoc;
1223 std::vector< std::vector< MCAuto<MEDFileAnyTypeFieldMultiTS> > > splitByMeshName;
1224 for(std::size_t j=0;j<allFMTSLeavesPerTimeSeriesSafe[i].size();j++)
1226 std::string meshName(allFMTSLeavesPerTimeSeriesSafe[i][j]->getMeshName());
1227 std::vector< std::string >::iterator it(std::find(meshNamesLoc.begin(),meshNamesLoc.end(),meshName));
1228 if(it==meshNamesLoc.end())
1230 meshNamesLoc.push_back(meshName);
1231 splitByMeshName.resize(splitByMeshName.size()+1);
1232 splitByMeshName.back().push_back(allFMTSLeavesPerTimeSeriesSafe[i][j]);
1235 splitByMeshName[std::distance(meshNamesLoc.begin(),it)].push_back(allFMTSLeavesPerTimeSeriesSafe[i][j]);
1237 _data_structure[i].resize(meshNamesLoc.size());
1238 for(std::size_t j=0;j<splitByMeshName.size();j++)
1240 std::vector< MCAuto<MEDFileFastCellSupportComparator> > fsp;
1241 std::vector< MEDFileAnyTypeFieldMultiTS *> sbmn(splitByMeshName[j].size());
1242 for(std::size_t k=0;k<splitByMeshName[j].size();k++)
1243 sbmn[k]=splitByMeshName[j][k];
1244 //getMeshWithName does not return a newly allocated object ! It is a true get* method !
1245 std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > commonSupSplit(MEDFileAnyTypeFieldMultiTS::SplitPerCommonSupport(sbmn,_ms->getMeshWithName(meshNamesLoc[j].c_str()),fsp));
1246 std::vector< std::vector< MCAuto<MEDFileAnyTypeFieldMultiTS> > > commonSupSplitSafe(commonSupSplit.size());
1247 this->_data_structure[i][j].resize(commonSupSplit.size());
1248 for(std::size_t k=0;k<commonSupSplit.size();k++)
1250 commonSupSplitSafe[k].resize(commonSupSplit[k].size());
1251 for(std::size_t l=0;l<commonSupSplit[k].size();l++)
1253 commonSupSplit[k][l]->incrRef();//because MEDFileAnyTypeFieldMultiTS::SplitPerCommonSupport does not increment pointers !
1254 commonSupSplitSafe[k][l]=commonSupSplit[k][l];
1257 for(std::size_t k=0;k<commonSupSplit.size();k++)
1258 this->_data_structure[i][j][k]=MEDFileFieldRepresentationLeaves(commonSupSplitSafe[k],fsp[k]);
1261 this->removeEmptyLeaves();
1263 this->computeFullNameInLeaves();
1266 void MEDFileFieldRepresentationTree::removeEmptyLeaves()
1268 std::vector< std::vector< std::vector< MEDFileFieldRepresentationLeaves > > > newSD;
1269 for(std::vector< std::vector< std::vector< MEDFileFieldRepresentationLeaves > > >::const_iterator it0=_data_structure.begin();it0!=_data_structure.end();it0++)
1271 std::vector< std::vector< MEDFileFieldRepresentationLeaves > > newSD0;
1272 for(std::vector< std::vector< MEDFileFieldRepresentationLeaves > >::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++)
1274 std::vector< MEDFileFieldRepresentationLeaves > newSD1;
1275 for(std::vector< MEDFileFieldRepresentationLeaves >::const_iterator it2=(*it1).begin();it2!=(*it1).end();it2++)
1277 newSD1.push_back(*it2);
1279 newSD0.push_back(newSD1);
1282 newSD.push_back(newSD0);
1286 bool MEDFileFieldRepresentationTree::IsFieldMeshRegardingInfo(const std::vector<std::string>& compInfos)
1288 if(compInfos.size()!=1)
1290 return compInfos[0]==COMPO_STR_TO_LOCATE_MESH_DA;
1293 std::string MEDFileFieldRepresentationTree::getDftMeshName() const
1295 return _data_structure[0][0][0].getMeshName();
1298 std::vector<double> MEDFileFieldRepresentationTree::getTimeSteps(int& lev0, const TimeKeeper& tk) const
1301 const MEDFileFieldRepresentationLeaves& leaf(getTheSingleActivated(lev0,lev1,lev2));
1302 return leaf.getTimeSteps(tk);
1305 vtkDataSet *MEDFileFieldRepresentationTree::buildVTKInstance(bool isStdOrMode, double timeReq, std::string& meshName, const TimeKeeper& tk) const
1308 const MEDFileFieldRepresentationLeaves& leaf(getTheSingleActivated(lev0,lev1,lev2));
1309 meshName=leaf.getMeshName();
1310 std::vector<double> ts(leaf.getTimeSteps(tk));
1311 std::size_t zeTimeId(0);
1314 std::vector<double> ts2(ts.size());
1315 std::transform(ts.begin(),ts.end(),ts2.begin(),std::bind2nd(std::plus<double>(),-timeReq));
1316 std::transform(ts2.begin(),ts2.end(),ts2.begin(),std::ptr_fun<double,double>(fabs));
1317 zeTimeId=std::distance(ts2.begin(),std::find_if(ts2.begin(),ts2.end(),std::bind2nd(std::less<double>(),1e-14)));
1320 if(zeTimeId==(int)ts.size())
1321 zeTimeId=std::distance(ts.begin(),std::find(ts.begin(),ts.end(),timeReq));
1322 if(zeTimeId==(int)ts.size())
1323 {//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.
1324 //In this case the default behaviour is taken. Keep the highest time step in this lower than timeReq.
1326 double valAttachedToPos(-std::numeric_limits<double>::max());
1327 for(std::size_t i=0;i<ts.size();i++)
1331 if(ts[i]>valAttachedToPos)
1334 valAttachedToPos=ts[i];
1339 {// timeReq is lower than all time steps (ts). So let's keep the lowest time step greater than timeReq.
1340 valAttachedToPos=std::numeric_limits<double>::max();
1341 for(std::size_t i=0;i<ts.size();i++)
1343 if(ts[i]<valAttachedToPos)
1346 valAttachedToPos=ts[i];
1351 std::ostringstream oss; oss.precision(15); oss << "request for time " << timeReq << " but not in ";
1352 std::copy(ts.begin(),ts.end(),std::ostream_iterator<double>(oss,","));
1353 oss << " ! Keep time " << valAttachedToPos << " at pos #" << zeTimeId;
1354 std::cerr << oss.str() << std::endl;
1358 tr=new MEDStdTimeReq((int)zeTimeId);
1360 tr=new MEDModeTimeReq(tk.getTheVectOfBool(),tk.getPostProcessedTime());
1361 vtkDataSet *ret(leaf.buildVTKInstanceNoTimeInterpolation(tr,_fields,_ms));
1366 const MEDFileFieldRepresentationLeaves& MEDFileFieldRepresentationTree::getTheSingleActivated(int& lev0, int& lev1, int& lev2) const
1368 int nbOfActivated(0);
1369 for(std::vector< std::vector< std::vector< MEDFileFieldRepresentationLeaves > > >::const_iterator it0=_data_structure.begin();it0!=_data_structure.end();it0++)
1370 for(std::vector< std::vector< MEDFileFieldRepresentationLeaves > >::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++)
1371 for(std::vector< MEDFileFieldRepresentationLeaves >::const_iterator it2=(*it1).begin();it2!=(*it1).end();it2++)
1372 if((*it2).isActivated())
1374 if(nbOfActivated!=1)
1376 std::ostringstream oss; oss << "MEDFileFieldRepresentationTree::getTheSingleActivated : Only one leaf must be activated ! Having " << nbOfActivated << " !";
1377 throw INTERP_KERNEL::Exception(oss.str().c_str());
1379 int i0(0),i1(0),i2(0);
1380 for(std::vector< std::vector< std::vector< MEDFileFieldRepresentationLeaves > > >::const_iterator it0=_data_structure.begin();it0!=_data_structure.end();it0++,i0++)
1381 for(std::vector< std::vector< MEDFileFieldRepresentationLeaves > >::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++,i1++)
1382 for(std::vector< MEDFileFieldRepresentationLeaves >::const_iterator it2=(*it1).begin();it2!=(*it1).end();it2++,i2++)
1383 if((*it2).isActivated())
1385 lev0=i0; lev1=i1; lev2=i2;
1388 throw INTERP_KERNEL::Exception("MEDFileFieldRepresentationTree::getTheSingleActivated : Internal error !");
1391 void MEDFileFieldRepresentationTree::printMySelf(std::ostream& os) const
1394 os << "#############################################" << std::endl;
1395 for(std::vector< std::vector< std::vector< MEDFileFieldRepresentationLeaves > > >::const_iterator it0=_data_structure.begin();it0!=_data_structure.end();it0++,i++)
1398 os << "TS" << i << std::endl;
1399 for(std::vector< std::vector< MEDFileFieldRepresentationLeaves > >::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++,j++)
1402 for(std::vector< MEDFileFieldRepresentationLeaves >::const_iterator it2=(*it1).begin();it2!=(*it1).end();it2++,k++)
1405 os << " " << (*it2).getMeshName() << std::endl;
1406 os << " Comp" << k << std::endl;
1407 (*it2).printMySelf(os);
1411 os << "$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$" << std::endl;
1414 std::map<std::string,bool> MEDFileFieldRepresentationTree::dumpState() const
1416 std::map<std::string,bool> ret;
1417 for(std::vector< std::vector< std::vector< MEDFileFieldRepresentationLeaves > > >::const_iterator it0=_data_structure.begin();it0!=_data_structure.end();it0++)
1418 for(std::vector< std::vector< MEDFileFieldRepresentationLeaves > >::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++)
1419 for(std::vector< MEDFileFieldRepresentationLeaves >::const_iterator it2=(*it1).begin();it2!=(*it1).end();it2++)
1420 (*it2).dumpState(ret);
1424 void MEDFileFieldRepresentationTree::AppendFieldFromMeshes(const MEDCoupling::MEDFileMeshes *ms, MEDCoupling::MEDFileFields *ret)
1427 throw INTERP_KERNEL::Exception("MEDFileFieldRepresentationTree::AppendFieldFromMeshes : internal error ! NULL ret !");
1428 for(int i=0;i<ms->getNumberOfMeshes();i++)
1430 MEDFileMesh *mm(ms->getMeshAtPos(i));
1431 std::vector<int> levs(mm->getNonEmptyLevels());
1432 MEDCoupling::MCAuto<MEDCoupling::MEDFileField1TS> f1tsMultiLev(MEDCoupling::MEDFileField1TS::New());
1433 MEDFileUMesh *mmu(dynamic_cast<MEDFileUMesh *>(mm));
1436 for(std::vector<int>::const_iterator it=levs.begin();it!=levs.end();it++)
1438 std::vector<INTERP_KERNEL::NormalizedCellType> gts(mmu->getGeoTypesAtLevel(*it));
1439 for(std::vector<INTERP_KERNEL::NormalizedCellType>::const_iterator gt=gts.begin();gt!=gts.end();gt++)
1441 MEDCoupling::MEDCouplingMesh *m(mmu->getDirectUndergroundSingleGeoTypeMesh(*gt));
1442 MEDCoupling::MCAuto<MEDCoupling::MEDCouplingFieldDouble> f(MEDCoupling::MEDCouplingFieldDouble::New(MEDCoupling::ON_CELLS));
1444 MEDCoupling::MCAuto<MEDCoupling::DataArrayDouble> arr(MEDCoupling::DataArrayDouble::New()); arr->alloc(f->getNumberOfTuplesExpected());
1445 arr->setInfoOnComponent(0,std::string(COMPO_STR_TO_LOCATE_MESH_DA));
1448 f->setName(BuildAUniqueArrayNameForMesh(mm->getName(),ret));
1449 f1tsMultiLev->setFieldNoProfileSBT(f);
1454 std::vector<int> levsExt(mm->getNonEmptyLevelsExt());
1455 if(levsExt.size()==levs.size()+1)
1457 MEDCoupling::MCAuto<MEDCoupling::MEDCouplingMesh> m(mm->getMeshAtLevel(1));
1458 MEDCoupling::MCAuto<MEDCoupling::MEDCouplingFieldDouble> f(MEDCoupling::MEDCouplingFieldDouble::New(MEDCoupling::ON_NODES));
1460 MEDCoupling::MCAuto<MEDCoupling::DataArrayDouble> arr(MEDCoupling::DataArrayDouble::New()); arr->alloc(m->getNumberOfNodes());
1461 arr->setInfoOnComponent(0,std::string(COMPO_STR_TO_LOCATE_MESH_DA));
1462 arr->iota(); f->setArray(arr);
1463 f->setName(BuildAUniqueArrayNameForMesh(mm->getName(),ret));
1464 f1tsMultiLev->setFieldNoProfileSBT(f);
1472 MEDCoupling::MCAuto<MEDCoupling::MEDCouplingMesh> m(mm->getMeshAtLevel(0));
1473 MEDCoupling::MCAuto<MEDCoupling::MEDCouplingFieldDouble> f(MEDCoupling::MEDCouplingFieldDouble::New(MEDCoupling::ON_CELLS));
1475 MEDCoupling::MCAuto<MEDCoupling::DataArrayDouble> arr(MEDCoupling::DataArrayDouble::New()); arr->alloc(f->getNumberOfTuplesExpected());
1476 arr->setInfoOnComponent(0,std::string(COMPO_STR_TO_LOCATE_MESH_DA));
1479 f->setName(BuildAUniqueArrayNameForMesh(mm->getName(),ret));
1480 f1tsMultiLev->setFieldNoProfileSBT(f);
1483 MEDCoupling::MCAuto<MEDCoupling::MEDFileFieldMultiTS> fmtsMultiLev(MEDCoupling::MEDFileFieldMultiTS::New());
1484 fmtsMultiLev->pushBackTimeStep(f1tsMultiLev);
1485 ret->pushField(fmtsMultiLev);
1489 std::string MEDFileFieldRepresentationTree::BuildAUniqueArrayNameForMesh(const std::string& meshName, const MEDCoupling::MEDFileFields *ret)
1491 const char KEY_STR_TO_AVOID_COLLIDE[]="MESH@";
1493 throw INTERP_KERNEL::Exception("MEDFileFieldRepresentationTree::BuildAUniqueArrayNameForMesh : internal error ! NULL ret !");
1494 std::vector<std::string> fieldNamesAlreadyExisting(ret->getFieldsNames());
1495 if(std::find(fieldNamesAlreadyExisting.begin(),fieldNamesAlreadyExisting.end(),meshName)==fieldNamesAlreadyExisting.end())
1497 std::string tmpName(KEY_STR_TO_AVOID_COLLIDE); tmpName+=meshName;
1498 while(std::find(fieldNamesAlreadyExisting.begin(),fieldNamesAlreadyExisting.end(),tmpName)!=fieldNamesAlreadyExisting.end())
1499 tmpName=std::string(KEY_STR_TO_AVOID_COLLIDE)+tmpName;
1503 MEDCoupling::MEDFileFields *MEDFileFieldRepresentationTree::BuildFieldFromMeshes(const MEDCoupling::MEDFileMeshes *ms)
1505 MEDCoupling::MCAuto<MEDCoupling::MEDFileFields> ret(MEDCoupling::MEDFileFields::New());
1506 AppendFieldFromMeshes(ms,ret);
1510 std::vector<std::string> MEDFileFieldRepresentationTree::SplitFieldNameIntoParts(const std::string& fullFieldName, char sep)
1512 std::vector<std::string> ret;
1514 while(pos!=std::string::npos)
1516 std::size_t curPos(fullFieldName.find_first_of(sep,pos));
1517 std::string elt(fullFieldName.substr(pos,curPos!=std::string::npos?curPos-pos:std::string::npos));
1519 pos=fullFieldName.find_first_not_of(sep,curPos);
1525 * Here the non regression tests.
1526 * const char inp0[]="";
1527 * const char exp0[]="";
1528 * const char inp1[]="field";
1529 * const char exp1[]="field";
1530 * const char inp2[]="_________";
1531 * const char exp2[]="_________";
1532 * const char inp3[]="field_p";
1533 * const char exp3[]="field_p";
1534 * const char inp4[]="field__p";
1535 * const char exp4[]="field_p";
1536 * const char inp5[]="field_p__";
1537 * const char exp5[]="field_p";
1538 * const char inp6[]="field_p_";
1539 * const char exp6[]="field_p";
1540 * const char inp7[]="field_____EDFGEG//sdkjf_____PP_______________";
1541 * const char exp7[]="field_EDFGEG//sdkjf_PP";
1542 * const char inp8[]="field_____EDFGEG//sdkjf_____PP";
1543 * const char exp8[]="field_EDFGEG//sdkjf_PP";
1544 * const char inp9[]="_field_____EDFGEG//sdkjf_____PP_______________";
1545 * const char exp9[]="field_EDFGEG//sdkjf_PP";
1546 * const char inp10[]="___field_____EDFGEG//sdkjf_____PP_______________";
1547 * const char exp10[]="field_EDFGEG//sdkjf_PP";
1549 std::string MEDFileFieldRepresentationTree::PostProcessFieldName(const std::string& fullFieldName)
1551 const char SEP('_');
1552 std::vector<std::string> v(SplitFieldNameIntoParts(fullFieldName,SEP));
1554 return fullFieldName;//should never happen
1558 return fullFieldName;
1562 std::string ret(v[0]);
1563 for(std::size_t i=1;i<v.size();i++)
1568 { ret+=SEP; ret+=v[i]; }
1574 return fullFieldName;
1580 TimeKeeper::TimeKeeper(int policy):_policy(policy)
1584 std::vector<double> TimeKeeper::getTimeStepsRegardingPolicy(const std::vector< std::pair<int,int> >& tsPairs, const std::vector<double>& ts) const
1589 return getTimeStepsRegardingPolicy0(tsPairs,ts);
1591 return getTimeStepsRegardingPolicy0(tsPairs,ts);
1593 throw INTERP_KERNEL::Exception("TimeKeeper::getTimeStepsRegardingPolicy : only policy 0 and 1 supported presently !");
1599 * if all of ts are in -1e299,1e299 and different each other pairs are ignored ts taken directly.
1600 * if all of ts are in -1e299,1e299 but some are not different each other ts are ignored pairs used
1601 * if some of ts are out of -1e299,1e299 ts are ignored pairs used
1603 std::vector<double> TimeKeeper::getTimeStepsRegardingPolicy0(const std::vector< std::pair<int,int> >& tsPairs, const std::vector<double>& ts) const
1605 std::size_t sz(ts.size());
1606 bool isInHumanRange(true);
1608 for(std::size_t i=0;i<sz;i++)
1611 if(ts[i]<=-1e299 || ts[i]>=1e299)
1612 isInHumanRange=false;
1615 return processedUsingPairOfIds(tsPairs);
1617 return processedUsingPairOfIds(tsPairs);
1618 _postprocessed_time=ts;
1619 return getPostProcessedTime();
1624 * idem than 0, except that ts is preaccumulated before invoking policy 0.
1626 std::vector<double> TimeKeeper::getTimeStepsRegardingPolicy1(const std::vector< std::pair<int,int> >& tsPairs, const std::vector<double>& ts) const
1628 std::size_t sz(ts.size());
1629 std::vector<double> ts2(sz);
1631 for(std::size_t i=0;i<sz;i++)
1636 return getTimeStepsRegardingPolicy0(tsPairs,ts2);
1639 int TimeKeeper::getTimeStepIdFrom(double timeReq) const
1641 std::size_t pos(std::distance(_postprocessed_time.begin(),std::find(_postprocessed_time.begin(),_postprocessed_time.end(),timeReq)));
1645 void TimeKeeper::printSelf(std::ostream& oss) const
1647 std::size_t sz(_activated_ts.size());
1648 for(std::size_t i=0;i<sz;i++)
1650 oss << "(" << i << "," << _activated_ts[i].first << "), ";
1654 std::vector<bool> TimeKeeper::getTheVectOfBool() const
1656 std::size_t sz(_activated_ts.size());
1657 std::vector<bool> ret(sz);
1658 for(std::size_t i=0;i<sz;i++)
1660 ret[i]=_activated_ts[i].first;
1665 std::vector<double> TimeKeeper::processedUsingPairOfIds(const std::vector< std::pair<int,int> >& tsPairs) const
1667 std::size_t sz(tsPairs.size());
1668 std::set<int> s0,s1;
1669 for(std::size_t i=0;i<sz;i++)
1670 { s0.insert(tsPairs[i].first); s1.insert(tsPairs[i].second); }
1673 _postprocessed_time.resize(sz);
1674 for(std::size_t i=0;i<sz;i++)
1675 _postprocessed_time[i]=(double)tsPairs[i].first;
1676 return getPostProcessedTime();
1680 _postprocessed_time.resize(sz);
1681 for(std::size_t i=0;i<sz;i++)
1682 _postprocessed_time[i]=(double)tsPairs[i].second;
1683 return getPostProcessedTime();
1685 //TimeKeeper::processedUsingPairOfIds : you are not a lucky guy ! All your time steps info in MEDFile are not discriminant taken one by one !
1686 _postprocessed_time.resize(sz);
1687 for(std::size_t i=0;i<sz;i++)
1688 _postprocessed_time[i]=(double)i;
1689 return getPostProcessedTime();
1692 void TimeKeeper::setMaxNumberOfTimeSteps(int maxNumberOfTS)
1694 _activated_ts.resize(maxNumberOfTS);
1695 for(int i=0;i<maxNumberOfTS;i++)
1697 std::ostringstream oss; oss << "000" << i;
1698 _activated_ts[i]=std::pair<bool,std::string>(true,oss.str());