1 // Copyright (C) 2007-2012 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.
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 (CEA/DEN)
21 #include "MEDFileField.hxx"
22 #include "MEDFileMesh.hxx"
23 #include "MEDLoaderBase.hxx"
24 #include "MEDFileUtilities.hxx"
26 #include "MEDCouplingFieldDouble.hxx"
27 #include "MEDCouplingFieldDiscretization.hxx"
29 #include "InterpKernelAutoPtr.hxx"
30 #include "CellModel.hxx"
35 extern med_geometry_type typmai[MED_N_CELL_FIXED_GEO];
36 extern INTERP_KERNEL::NormalizedCellType typmai2[MED_N_CELL_FIXED_GEO];
37 extern med_geometry_type typmainoeud[1];
38 extern med_geometry_type typmai3[32];
40 using namespace ParaMEDMEM;
42 MEDFileFieldLoc *MEDFileFieldLoc::New(med_idt fid, const char *locName)
44 return new MEDFileFieldLoc(fid,locName);
47 MEDFileFieldLoc *MEDFileFieldLoc::New(med_idt fid, int id)
49 return new MEDFileFieldLoc(fid,id);
52 MEDFileFieldLoc *MEDFileFieldLoc::New(const char *locName, INTERP_KERNEL::NormalizedCellType geoType, const std::vector<double>& refCoo, const std::vector<double>& gsCoo, const std::vector<double>& w)
54 return new MEDFileFieldLoc(locName,geoType,refCoo,gsCoo,w);
57 MEDFileFieldLoc::MEDFileFieldLoc(med_idt fid, const char *locName):_name(locName)
59 med_geometry_type geotype;
60 med_geometry_type sectiongeotype;
62 INTERP_KERNEL::AutoPtr<char> geointerpname=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
63 INTERP_KERNEL::AutoPtr<char> sectionmeshname=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
64 MEDlocalizationInfoByName(fid,locName,&geotype,&_dim,&_nb_gauss_pt,geointerpname,sectionmeshname,&nsectionmeshcell,§iongeotype);
65 _geo_type=(INTERP_KERNEL::NormalizedCellType)(std::distance(typmai3,std::find(typmai3,typmai3+32,geotype)));
66 const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
67 _nb_node_per_cell=cm.getNumberOfNodes();
68 _ref_coo.resize(_dim*_nb_node_per_cell);
69 _gs_coo.resize(_dim*_nb_gauss_pt);
70 _w.resize(_nb_gauss_pt);
71 MEDlocalizationRd(fid,locName,MED_FULL_INTERLACE,&_ref_coo[0],&_gs_coo[0],&_w[0]);
74 MEDFileFieldLoc::MEDFileFieldLoc(med_idt fid, int id)
76 med_geometry_type geotype;
77 med_geometry_type sectiongeotype;
79 INTERP_KERNEL::AutoPtr<char> locName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
80 INTERP_KERNEL::AutoPtr<char> geointerpname=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
81 INTERP_KERNEL::AutoPtr<char> sectionmeshname=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
82 MEDlocalizationInfo(fid,id+1,locName,&geotype,&_dim,&_nb_gauss_pt,geointerpname,sectionmeshname,&nsectionmeshcell,§iongeotype);
84 _geo_type=(INTERP_KERNEL::NormalizedCellType)(std::distance(typmai3,std::find(typmai3,typmai3+32,geotype)));
85 const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
86 _nb_node_per_cell=cm.getNumberOfNodes();
87 _ref_coo.resize(_dim*_nb_node_per_cell);
88 _gs_coo.resize(_dim*_nb_gauss_pt);
89 _w.resize(_nb_gauss_pt);
90 MEDlocalizationRd(fid,locName,MED_FULL_INTERLACE,&_ref_coo[0],&_gs_coo[0],&_w[0]);
93 MEDFileFieldLoc::MEDFileFieldLoc(const char *locName, INTERP_KERNEL::NormalizedCellType geoType,
94 const std::vector<double>& refCoo, const std::vector<double>& gsCoo, const std::vector<double>& w):_name(locName),_geo_type(geoType),_ref_coo(refCoo),_gs_coo(gsCoo),
97 const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
98 _dim=cm.getDimension();
99 _nb_node_per_cell=cm.getNumberOfNodes();
100 _nb_gauss_pt=_w.size();
103 MEDFileFieldLoc *MEDFileFieldLoc::deepCpy() const
105 return new MEDFileFieldLoc(*this);
108 std::size_t MEDFileFieldLoc::getHeapMemorySize() const
110 return (_ref_coo.capacity()+_gs_coo.capacity()+_w.capacity())*sizeof(double)+_name.capacity();
113 void MEDFileFieldLoc::simpleRepr(std::ostream& oss) const
115 static const char OFF7[]="\n ";
116 oss << "\"" << _name << "\"" << OFF7;
117 oss << "GeoType=" << INTERP_KERNEL::CellModel::GetCellModel(_geo_type).getRepr() << OFF7;
118 oss << "Dimension=" << _dim << OFF7;
119 oss << "Number of Gauss points=" << _nb_gauss_pt << OFF7;
120 oss << "Number of nodes per cell=" << _nb_node_per_cell << OFF7;
121 oss << "RefCoords="; std::copy(_ref_coo.begin(),_ref_coo.end(),std::ostream_iterator<double>(oss," ")); oss << OFF7;
122 oss << "Weights="; std::copy(_w.begin(),_w.end(),std::ostream_iterator<double>(oss," ")); oss << OFF7;
123 oss << "GaussPtsCoords="; std::copy(_gs_coo.begin(),_gs_coo.end(),std::ostream_iterator<double>(oss," ")); oss << std::endl;
126 void MEDFileFieldLoc::setName(const char *name)
131 bool MEDFileFieldLoc::isEqual(const MEDFileFieldLoc& other, double eps) const
133 if(_name!=other._name)
137 if(_nb_gauss_pt!=other._nb_gauss_pt)
139 if(_nb_node_per_cell!=other._nb_node_per_cell)
141 if(_geo_type!=other._geo_type)
143 if(MEDCouplingGaussLocalization::AreAlmostEqual(_ref_coo,other._ref_coo,eps))
145 if(MEDCouplingGaussLocalization::AreAlmostEqual(_gs_coo,other._gs_coo,eps))
147 if(MEDCouplingGaussLocalization::AreAlmostEqual(_w,other._w,eps))
153 void MEDFileFieldLoc::writeLL(med_idt fid) const
155 MEDlocalizationWr(fid,_name.c_str(),typmai3[(int)_geo_type],_dim,&_ref_coo[0],MED_FULL_INTERLACE,_nb_gauss_pt,&_gs_coo[0],&_w[0],MED_NO_INTERPOLATION,MED_NO_MESH_SUPPORT);
158 std::string MEDFileFieldLoc::repr() const
160 std::ostringstream oss; oss.precision(15);
161 const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
162 oss << "Localization \"" << _name << "\" :\n" << " - Geometric Type : " << cm.getRepr();
163 oss << "\n - Dimension : " << _dim << "\n - Number of gauss points : ";
164 oss << _nb_gauss_pt << "\n - Number of nodes in cell : " << _nb_node_per_cell;
165 oss << "\n - Ref coords are : ";
166 int sz=_ref_coo.size();
169 int nbOfTuples=sz/_dim;
170 for(int i=0;i<nbOfTuples;i++)
173 for(int j=0;j<_dim;j++)
174 { oss << _ref_coo[i*_dim+j]; if(j!=_dim-1) oss << ", "; }
179 std::copy(_ref_coo.begin(),_ref_coo.end(),std::ostream_iterator<double>(oss," "));
180 oss << "\n - Gauss coords in reference element : ";
184 int nbOfTuples=sz/_dim;
185 for(int i=0;i<nbOfTuples;i++)
188 for(int j=0;j<_dim;j++)
189 { oss << _gs_coo[i*_dim+j]; if(j!=_dim-1) oss << ", "; }
194 std::copy(_gs_coo.begin(),_gs_coo.end(),std::ostream_iterator<double>(oss," "));
195 oss << "\n - Weights of Gauss coords are : "; std::copy(_w.begin(),_w.end(),std::ostream_iterator<double>(oss," "));
199 void MEDFileFieldPerMeshPerTypePerDisc::assignFieldNoProfile(int& start, int offset, int nbOfCells, const MEDCouplingFieldDouble *field, MEDFileFieldGlobsReal& glob) throw(INTERP_KERNEL::Exception)
201 _type=field->getTypeOfField();
202 const DataArrayDouble *da=field->getArray();
208 getArray()->setContigPartOfSelectedValues2(_start,da,offset,offset+nbOfCells,1);
209 _end=_start+nbOfCells;
215 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr=field->getDiscretization()->getOffsetArr(field->getMesh());
216 const int *arrPtr=arr->getConstPointer();
217 getArray()->setContigPartOfSelectedValues2(_start,da,arrPtr[offset],arrPtr[offset+nbOfCells],1);
218 _end=_start+(arrPtr[offset+nbOfCells]-arrPtr[offset]);
224 const MEDCouplingFieldDiscretization *disc=field->getDiscretization();
225 const MEDCouplingGaussLocalization& gsLoc=field->getGaussLocalization(_loc_id);
226 const MEDCouplingFieldDiscretizationGauss *disc2=dynamic_cast<const MEDCouplingFieldDiscretizationGauss *>(disc);
228 throw INTERP_KERNEL::Exception("assignFieldNoProfile : invalid call to this method ! Internal Error !");
229 const DataArrayInt *dai=disc2->getArrayOfDiscIds();
230 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> dai2=disc2->getOffsetArr(field->getMesh());
231 const int *dai2Ptr=dai2->getConstPointer();
232 int nbi=gsLoc.getWeights().size();
233 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da2=dai->selectByTupleId2(offset,offset+nbOfCells,1);
234 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da3=da2->getIdsEqual(_loc_id);
235 const int *da3Ptr=da3->getConstPointer();
236 if(da3->getNumberOfTuples()!=nbOfCells)
237 {//profile : for gauss even in NoProfile !!!
238 std::ostringstream oss; oss << "Pfl_" << getName() << "_" << INTERP_KERNEL::CellModel::GetCellModel(getGeoType()).getRepr() << "_" << _loc_id;
240 da3->setName(_profile.c_str());
241 glob.appendProfile(da3);
243 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da4=DataArrayInt::New();
244 _nval=da3->getNbOfElems();
245 da4->alloc(_nval*nbi,1);
246 int *da4Ptr=da4->getPointer();
247 for(int i=0;i<_nval;i++)
249 int ref=dai2Ptr[offset+da3Ptr[i]];
250 for(int j=0;j<nbi;j++)
253 std::ostringstream oss2; oss2 << "Loc_" << getName() << "_" << INTERP_KERNEL::CellModel::GetCellModel(getGeoType()).getRepr() << "_" << _loc_id;
254 _localization=oss2.str();
255 getArray()->setContigPartOfSelectedValues(_start,da,da4);
256 _end=_start+_nval*nbi;
257 glob.appendLoc(_localization.c_str(),getGeoType(),gsLoc.getRefCoords(),gsLoc.getGaussCoords(),gsLoc.getWeights());
261 throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::assignFieldNoProfile : not implemented yet for such discretization type of field !");
267 * Leaf method of field with profile assignement. This method is the most general one. No optimization is done here.
268 * \param [in] pflName input containing name of profile if any. 0 if no profile (except for GAUSS_PT where a no profile can hide a profile when splitted by loc_id).
269 * \param [in] multiTypePfl is the end user profile specified in high level API
270 * \param [in] idsInPfl is the selection into the \a multiTypePfl whole profile that corresponds to the current geometric type.
271 * \param [in] locIds is the profile needed to be created for MED file format. It can be null if all cells of current geometric type are fetched in \a multiTypePfl.
272 * \b WARNING if not null the MED file profile can be subdivided again in case of Gauss points.
273 * \param [in] mesh is the mesh coming from the MEDFileMesh instance in correspondance with the MEDFileField. The mesh inside the \a field is simply ignored.
275 void MEDFileFieldPerMeshPerTypePerDisc::assignFieldProfile(int& start, const DataArrayInt *multiTypePfl, const DataArrayInt *idsInPfl, DataArrayInt *locIds, int nbOfEltsInWholeMesh, const MEDCouplingFieldDouble *field, const MEDCouplingMesh *mesh, MEDFileFieldGlobsReal& glob) throw(INTERP_KERNEL::Exception)
278 _type=field->getTypeOfField();
279 std::string pflName(multiTypePfl->getName());
280 std::ostringstream oss; oss << pflName;
281 if(_type!=ON_NODES) { const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(getGeoType()); oss << "_" << cm.getRepr(); } else { oss << "_NODE"; }
285 throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::assignFieldProfile : existing profile with empty name !");
286 if(_type!=ON_GAUSS_PT)
288 locIds->setName(oss.str().c_str());
289 glob.appendProfile(locIds);
293 const DataArrayDouble *da=field->getArray();
299 _nval=idsInPfl->getNumberOfTuples();
300 getArray()->setContigPartOfSelectedValues2(_start,da,0,da->getNumberOfTuples(),1);
306 _nval=idsInPfl->getNumberOfTuples();
307 getArray()->setContigPartOfSelectedValues(_start,da,idsInPfl);
313 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr=field->getDiscretization()->getOffsetArr(mesh);
314 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr2=arr->deltaShiftIndex();
315 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr3=arr2->selectByTupleId(multiTypePfl->begin(),multiTypePfl->end());
316 arr3->computeOffsets2();
317 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmp=idsInPfl->buildExplicitArrByRanges(arr3);
318 int trueNval=tmp->getNumberOfTuples();
319 _nval=idsInPfl->getNumberOfTuples();
320 getArray()->setContigPartOfSelectedValues(_start,da,tmp);
321 _end=_start+trueNval;
326 const MEDCouplingFieldDiscretizationGauss *disc2=dynamic_cast<const MEDCouplingFieldDiscretizationGauss *>(field->getDiscretization());
328 throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : invalid call to this method ! Internal Error !");
329 const DataArrayInt *da1=disc2->getArrayOfDiscIds();
330 const MEDCouplingGaussLocalization& gsLoc=field->getGaussLocalization(_loc_id);
331 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da2=da1->selectByTupleId(idsInPfl->begin(),idsInPfl->end());
332 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da3=da2->getIdsEqual(_loc_id);
333 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da4=idsInPfl->selectByTupleId(da3->begin(),da3->end());
335 MEDCouplingAutoRefCountObjectPtr<MEDCouplingMesh> mesh2=mesh->buildPart(multiTypePfl->begin(),multiTypePfl->end());
336 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr=disc2->getOffsetArr(mesh2);
338 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmp=DataArrayInt::New();
340 for(const int *pt=da4->begin();pt!=da4->end();pt++)
341 trueNval+=arr->getIJ(*pt+1,0)-arr->getIJ(*pt,0);
342 tmp->alloc(trueNval,1);
343 int *tmpPtr=tmp->getPointer();
344 for(const int *pt=da4->begin();pt!=da4->end();pt++)
345 for(int j=arr->getIJ(*pt,0);j<arr->getIJ(*pt+1,0);j++)
348 _nval=da4->getNumberOfTuples();
349 getArray()->setContigPartOfSelectedValues(_start,da,tmp);
350 _end=_start+trueNval;
351 oss << "_loc_" << _loc_id;
354 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da5=locIds->selectByTupleId(da3->begin(),da3->end());
355 da5->setName(oss.str().c_str());
356 glob.appendProfile(da5);
361 if(da3->getNumberOfTuples()!=nbOfEltsInWholeMesh || !da3->isIdentity())
363 da3->setName(oss.str().c_str());
364 glob.appendProfile(da3);
368 std::ostringstream oss2; oss2 << "Loc_" << getName() << "_" << INTERP_KERNEL::CellModel::GetCellModel(getGeoType()).getRepr() << "_" << _loc_id;
369 _localization=oss2.str();
370 glob.appendLoc(_localization.c_str(),getGeoType(),gsLoc.getRefCoords(),gsLoc.getGaussCoords(),gsLoc.getWeights());
374 throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::assignFieldProfile : not implemented yet for such discretization type of field !");
379 void MEDFileFieldPerMeshPerTypePerDisc::assignNodeFieldNoProfile(int& start, const MEDCouplingFieldDouble *field, MEDFileFieldGlobsReal& glob) throw(INTERP_KERNEL::Exception)
382 _nval=field->getArray()->getNumberOfTuples();
383 getArray()->setContigPartOfSelectedValues2(_start,field->getArray(),0,_nval,1);
388 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerTypePerDisc::NewOnRead(MEDFileFieldPerMeshPerType *fath, TypeOfField type, int profileIt) throw(INTERP_KERNEL::Exception)
390 return new MEDFileFieldPerMeshPerTypePerDisc(fath,type,profileIt);
393 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerTypePerDisc::New(MEDFileFieldPerMeshPerType *fath, TypeOfField type, int locId)
395 return new MEDFileFieldPerMeshPerTypePerDisc(fath,type,locId,std::string());
398 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerTypePerDisc::New(const MEDFileFieldPerMeshPerTypePerDisc& other)
400 return new MEDFileFieldPerMeshPerTypePerDisc(other);
403 std::size_t MEDFileFieldPerMeshPerTypePerDisc::getHeapMemorySize() const
405 return _profile.capacity()+_localization.capacity()+5*sizeof(int);
408 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerTypePerDisc::deepCpy(MEDFileFieldPerMeshPerType *father) const throw(INTERP_KERNEL::Exception)
410 MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> ret=new MEDFileFieldPerMeshPerTypePerDisc(*this);
415 MEDFileFieldPerMeshPerTypePerDisc::MEDFileFieldPerMeshPerTypePerDisc(MEDFileFieldPerMeshPerType *fath, TypeOfField atype, int profileIt) throw(INTERP_KERNEL::Exception)
416 try:_type(atype),_father(fath)
419 catch(INTERP_KERNEL::Exception& e)
424 MEDFileFieldPerMeshPerTypePerDisc::MEDFileFieldPerMeshPerTypePerDisc(MEDFileFieldPerMeshPerType *fath, TypeOfField type, int locId, const std::string& dummy):_type(type),_father(fath),_loc_id(locId)
428 MEDFileFieldPerMeshPerTypePerDisc::MEDFileFieldPerMeshPerTypePerDisc(const MEDFileFieldPerMeshPerTypePerDisc& other):_type(other._type),_father(0),_start(other._start),_end(other._end),_nval(other._nval),_profile(other._profile),_localization(other._localization),_loc_id(other._loc_id),_tmp_work1(other._tmp_work1)
432 MEDFileFieldPerMeshPerTypePerDisc::MEDFileFieldPerMeshPerTypePerDisc():_type(ON_CELLS),_father(0),_start(-std::numeric_limits<int>::max()),_end(-std::numeric_limits<int>::max()),
433 _nval(-std::numeric_limits<int>::max()),_loc_id(-std::numeric_limits<int>::max())
437 const MEDFileFieldPerMeshPerType *MEDFileFieldPerMeshPerTypePerDisc::getFather() const
442 void MEDFileFieldPerMeshPerTypePerDisc::prepareLoading(med_idt fid, int profileIt, int& start) throw(INTERP_KERNEL::Exception)
444 INTERP_KERNEL::AutoPtr<char> locname=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
445 INTERP_KERNEL::AutoPtr<char> pflname=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
446 std::string fieldName=getName();
447 std::string meshName=getMeshName();
448 int iteration=getIteration();
449 int order=getOrder();
450 TypeOfField type=getType();
451 INTERP_KERNEL::NormalizedCellType geoType=getGeoType();
453 med_geometry_type mgeoti;
454 med_entity_type menti=MEDFileFieldPerMeshPerType::ConvertIntoMEDFileType(type,geoType,mgeoti);
455 _nval=MEDfieldnValueWithProfile(fid,fieldName.c_str(),iteration,order,menti,mgeoti,profileIt,MED_COMPACT_PFLMODE,
456 pflname,&profilesize,locname,&nbi);
457 _profile=MEDLoaderBase::buildStringFromFortran(pflname,MED_NAME_SIZE);
458 _localization=MEDLoaderBase::buildStringFromFortran(locname,MED_NAME_SIZE);
460 _end=start+_nval*nbi;
462 if(type==ON_CELLS && !_localization.empty())
464 if(_localization!="MED_GAUSS_ELNO")//For compatibily with MED2.3
465 setType(ON_GAUSS_PT);
468 setType(ON_GAUSS_NE);
469 _localization.clear();
474 void MEDFileFieldPerMeshPerTypePerDisc::finishLoading(med_idt fid, int profileIt, int ft) throw(INTERP_KERNEL::Exception)
476 std::string fieldName=getName();
477 std::string meshName=getMeshName();
478 int iteration=getIteration();
479 int order=getOrder();
480 TypeOfField type=getType();
481 INTERP_KERNEL::NormalizedCellType geoType=getGeoType();
482 med_geometry_type mgeoti;
483 med_entity_type menti=MEDFileFieldPerMeshPerType::ConvertIntoMEDFileType(type,geoType,mgeoti);
484 DataArrayDouble *arr=getArray();
485 double *startFeeding=arr->getPointer()+_start*arr->getNumberOfComponents();
490 MEDfieldValueWithProfileRd(fid,fieldName.c_str(),iteration,order,menti,mgeoti,MED_COMPACT_PFLMODE,
491 _profile.c_str(),MED_FULL_INTERLACE,MED_ALL_CONSTITUENT,reinterpret_cast<unsigned char*>(startFeeding));
496 INTERP_KERNEL::AutoPtr<int> tmpp=new int[(_end-_start)*arr->getNumberOfComponents()];
497 MEDfieldValueWithProfileRd(fid,fieldName.c_str(),iteration,order,menti,mgeoti,MED_COMPACT_PFLMODE,
498 _profile.c_str(),MED_FULL_INTERLACE,MED_ALL_CONSTITUENT,reinterpret_cast<unsigned char*>((int *)tmpp));
499 std::copy((const int *)tmpp,(const int *)tmpp+(_end-_start)*arr->getNumberOfComponents(),startFeeding);
503 throw INTERP_KERNEL::Exception("Error on array reading ! Unrecognized type of field ! Should be in FLOAT64 or INT32 !");
508 * Set a \c this->_start **and** \c this->_end keeping the same delta between the two.
510 void MEDFileFieldPerMeshPerTypePerDisc::setNewStart(int newValueOfStart) throw(INTERP_KERNEL::Exception)
512 int delta=_end-_start;
513 _start=newValueOfStart;
517 int MEDFileFieldPerMeshPerTypePerDisc::getIteration() const
519 return _father->getIteration();
522 int MEDFileFieldPerMeshPerTypePerDisc::getOrder() const
524 return _father->getOrder();
527 double MEDFileFieldPerMeshPerTypePerDisc::getTime() const
529 return _father->getTime();
532 std::string MEDFileFieldPerMeshPerTypePerDisc::getName() const
534 return _father->getName();
537 std::string MEDFileFieldPerMeshPerTypePerDisc::getMeshName() const
539 return _father->getMeshName();
542 void MEDFileFieldPerMeshPerTypePerDisc::simpleRepr(int bkOffset, std::ostream& oss, int id) const
544 const char startLine[]=" ## ";
545 std::string startLine2(bkOffset,' ');
546 startLine2+=startLine;
547 MEDCouplingFieldDiscretization *tmp=MEDCouplingFieldDiscretization::New(_type);
548 oss << startLine2 << "Localization #" << id << "." << std::endl;
549 oss << startLine2 << " Type=" << tmp->getRepr() << "." << std::endl;
551 oss << startLine2 << " This type discretization lies on profile : \"" << _profile << "\" and on the following localization : \"" << _localization << "\"." << std::endl;
552 oss << startLine2 << " This type discretization has " << _end-_start << " tuples (start=" << _start << ", end=" << _end << ")." << std::endl;
553 oss << startLine2 << " This type discretization has " << (_end-_start)/_nval << " integration points." << std::endl;
556 TypeOfField MEDFileFieldPerMeshPerTypePerDisc::getType() const
561 void MEDFileFieldPerMeshPerTypePerDisc::fillTypesOfFieldAvailable(std::set<TypeOfField>& types) const throw(INTERP_KERNEL::Exception)
566 void MEDFileFieldPerMeshPerTypePerDisc::setType(TypeOfField newType)
571 INTERP_KERNEL::NormalizedCellType MEDFileFieldPerMeshPerTypePerDisc::getGeoType() const
573 return _father->getGeoType();
576 int MEDFileFieldPerMeshPerTypePerDisc::getNumberOfComponents() const
578 return _father->getNumberOfComponents();
581 int MEDFileFieldPerMeshPerTypePerDisc::getNumberOfTuples() const
586 DataArrayDouble *MEDFileFieldPerMeshPerTypePerDisc::getArray()
588 return _father->getArray();
591 const DataArrayDouble *MEDFileFieldPerMeshPerTypePerDisc::getArray() const
593 const MEDFileFieldPerMeshPerType *fath=_father;
594 return fath->getArray();
597 const std::vector<std::string>& MEDFileFieldPerMeshPerTypePerDisc::getInfo() const
599 return _father->getInfo();
602 std::string MEDFileFieldPerMeshPerTypePerDisc::getProfile() const
607 void MEDFileFieldPerMeshPerTypePerDisc::setProfile(const char *newPflName)
612 std::string MEDFileFieldPerMeshPerTypePerDisc::getLocalization() const
614 return _localization;
617 void MEDFileFieldPerMeshPerTypePerDisc::setLocalization(const char *newLocName)
619 _localization=newLocName;
622 void MEDFileFieldPerMeshPerTypePerDisc::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
624 for(std::vector< std::pair<std::vector<std::string>, std::string > >::const_iterator it2=mapOfModif.begin();it2!=mapOfModif.end();it2++)
626 if(std::find((*it2).first.begin(),(*it2).first.end(),_profile)!=(*it2).first.end())
628 _profile=(*it2).second;
634 void MEDFileFieldPerMeshPerTypePerDisc::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
636 for(std::vector< std::pair<std::vector<std::string>, std::string > >::const_iterator it2=mapOfModif.begin();it2!=mapOfModif.end();it2++)
638 if(std::find((*it2).first.begin(),(*it2).first.end(),_localization)!=(*it2).first.end())
640 _localization=(*it2).second;
646 void MEDFileFieldPerMeshPerTypePerDisc::getFieldAtLevel(TypeOfField type, const MEDFileFieldGlobsReal *glob, std::vector< std::pair<int,int> >& dads, std::vector<const DataArrayInt *>& pfls, std::vector<int>& locs, std::vector<INTERP_KERNEL::NormalizedCellType>& geoTypes) const
650 dads.push_back(std::pair<int,int>(_start,_end));
651 geoTypes.push_back(getGeoType());
656 pfls.push_back(glob->getProfile(_profile.c_str()));
658 if(_localization.empty())
662 locs.push_back(glob->getLocalizationId(_localization.c_str()));
666 void MEDFileFieldPerMeshPerTypePerDisc::fillValues(int discId, int& startEntryId, std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
668 entries[startEntryId]=std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int> ,std::pair<int,int> >(std::pair<INTERP_KERNEL::NormalizedCellType,int>(getGeoType(),discId),std::pair<int,int>(_start,_end));
672 void MEDFileFieldPerMeshPerTypePerDisc::writeLL(med_idt fid) const throw(INTERP_KERNEL::Exception)
674 TypeOfField type=getType();
675 INTERP_KERNEL::NormalizedCellType geoType=getGeoType();
676 med_geometry_type mgeoti;
677 med_entity_type menti=MEDFileFieldPerMeshPerType::ConvertIntoMEDFileType(type,geoType,mgeoti);
678 const DataArrayDouble *arr=getArray();
679 const double *locToWrite=arr->getConstPointer()+_start*arr->getNumberOfComponents();
680 MEDfieldValueWithProfileWr(fid,getName().c_str(),getIteration(),getOrder(),getTime(),menti,mgeoti,
681 MED_COMPACT_PFLMODE,_profile.c_str(),_localization.c_str(),MED_FULL_INTERLACE,MED_ALL_CONSTITUENT,_nval,
682 reinterpret_cast<const unsigned char*>(locToWrite));
685 void MEDFileFieldPerMeshPerTypePerDisc::getCoarseData(TypeOfField& type, std::pair<int,int>& dad, std::string& pfl, std::string& loc) const throw(INTERP_KERNEL::Exception)
690 dad.first=_start; dad.second=_end;
694 * \param [in] codeOfMesh is of format returned by MEDCouplingUMesh::getDistributionOfTypes. And for each *i* oldCode[3*i+2] gives the position (MEDFileUMesh::PutInThirdComponentOfCodeOffset).
695 * This code corresponds to the distribution of types in the corresponding mesh.
696 * \param [out] ptToFill memory zone where the output will be stored.
697 * \return the size of data pushed into output param \a ptToFill
699 int MEDFileFieldPerMeshPerTypePerDisc::fillEltIdsFromCode(int offset, const std::vector<int>& codeOfMesh, const MEDFileFieldGlobsReal& glob, int *ptToFill) const throw(INTERP_KERNEL::Exception)
702 std::ostringstream oss;
703 std::size_t nbOfType=codeOfMesh.size()/3;
705 for(std::size_t i=0;i<nbOfType && found==-1;i++)
706 if(getGeoType()==(INTERP_KERNEL::NormalizedCellType)codeOfMesh[3*i])
710 const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(getGeoType());
711 oss << "MEDFileFieldPerMeshPerTypePerDisc::fillEltIdsFromCode : not found geometric type " << cm.getRepr() << " in the referenced mesh of field !";
712 throw INTERP_KERNEL::Exception(oss.str().c_str());
717 if(_nval!=codeOfMesh[3*found+1])
719 const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(getGeoType());
720 oss << "MEDFileFieldPerMeshPerTypePerDisc::fillEltIdsFromCode : for geometric type " << cm.getRepr() << " number of elt ids in mesh is equal to " << _nval;
721 oss << " whereas mesh has " << codeOfMesh[3*found+1] << " for this geometric type !";
722 throw INTERP_KERNEL::Exception(oss.str().c_str());
724 for(int ii=codeOfMesh[3*found+2];ii<codeOfMesh[3*found+2]+_nval;ii++)
729 const DataArrayInt *pfl=glob.getProfile(_profile.c_str());
730 if(pfl->getNumberOfTuples()!=_nval)
732 const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(getGeoType());
733 oss << "MEDFileFieldPerMeshPerTypePerDisc::fillEltIdsFromCode : for geometric type " << cm.getRepr() << ", field is defined on profile \"" << _profile << "\" and size of profile is ";
735 oss << pfl->getNumberOfTuples() << " whereas the number of ids is set to " << _nval << " for this geometric type !";
736 throw INTERP_KERNEL::Exception(oss.str().c_str());
738 int offset2=codeOfMesh[3*found+2];
739 for(const int *pflId=pfl->begin();pflId!=pfl->end();pflId++)
741 if(*pflId<codeOfMesh[3*found+1])
742 *work++=offset2+*pflId;
748 int MEDFileFieldPerMeshPerTypePerDisc::fillTupleIds(int *ptToFill) const throw(INTERP_KERNEL::Exception)
750 for(int i=_start;i<_end;i++)
755 int MEDFileFieldPerMeshPerTypePerDisc::ConvertType(TypeOfField type, int locId) throw(INTERP_KERNEL::Exception)
766 throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::ConvertType : not managed type of field !");
770 std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> > MEDFileFieldPerMeshPerTypePerDisc::SplitPerDiscretization(const std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>& entries)
773 std::map<std::pair<std::string,TypeOfField>,int> m;
774 std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> > ret;
775 for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=entries.begin();it!=entries.end();it++)
776 if(m.find(std::pair<std::string,TypeOfField>((*it)->getLocalization(),(*it)->getType()))==m.end())
777 m[std::pair<std::string,TypeOfField>((*it)->getLocalization(),(*it)->getType())]=id++;
779 for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=entries.begin();it!=entries.end();it++)
780 ret[m[std::pair<std::string,TypeOfField>((*it)->getLocalization(),(*it)->getType())]].push_back(*it);
785 * - \c this->_loc_id mutable attribute is used for elt id in mesh offsets.
787 * \param [in] offset the offset id used to take into account that \a result is not compulsary empty in input
788 * \param [in] entriesOnSameDisc some entries **on same localization** if not the result can be invalid. The _start and _end on them are relative to \a arr parameter.
789 * \param [in] explicitIdsInMesh ids in mesh of the considered chunk.
790 * \param [in] newCode one of the input parameter to explicit the new geo type dispatch (in classical format same than those asked by MEDFileFields::renumberEntitiesLyingOnMesh)
791 * \param [in,out] glob if necessary by the method, new profiles can be added to it
792 * \param [in,out] arr after the call of this method \a arr is renumbered to be compliant with added entries to \a result.
793 * \param [out] result All new entries will be appended on it.
794 * \return false if the configuration of renumbering leads to an unnecessary resplit of input \a entriesOnSameDisc. If not true is returned (the most general case !)
796 bool MEDFileFieldPerMeshPerTypePerDisc::RenumberChunks(int offset, const std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>& entriesOnSameDisc,
797 const DataArrayInt *explicitIdsInMesh,
798 const std::vector<int>& newCode,
799 MEDFileFieldGlobsReal& glob, DataArrayDouble *arr,
800 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >& result)
802 if(entriesOnSameDisc.empty())
804 TypeOfField type=entriesOnSameDisc[0]->getType();
805 int szEntities=0,szTuples=0;
806 for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=entriesOnSameDisc.begin();it!=entriesOnSameDisc.end();it++)
807 { szEntities+=(*it)->_nval; szTuples+=(*it)->_end-(*it)->_start; }
808 int nbi=szTuples/szEntities;
809 if(szTuples%szEntities!=0)
810 throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::RenumberChunks : internal error the splitting into same dicretization failed !");
811 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> renumTuples=DataArrayInt::New(); renumTuples->alloc(szTuples,1);
812 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ranges=MEDCouplingUMesh::ComputeRangesFromTypeDistribution(newCode);
813 std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > newGeoTypesPerChunk(entriesOnSameDisc.size());
814 std::vector< const DataArrayInt * > newGeoTypesPerChunk2(entriesOnSameDisc.size());
815 std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > newGeoTypesPerChunk_bis(entriesOnSameDisc.size());
816 std::vector< const DataArrayInt * > newGeoTypesPerChunk3(entriesOnSameDisc.size());
817 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> newGeoTypesPerChunk4=DataArrayInt::New(); newGeoTypesPerChunk4->alloc(szEntities,nbi);
819 for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=entriesOnSameDisc.begin();it!=entriesOnSameDisc.end();it++,id++)
821 int startOfEltIdOfChunk=(*it)->_start;
822 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> newEltIds=explicitIdsInMesh->substr(startOfEltIdOfChunk,startOfEltIdOfChunk+(*it)->_nval);
823 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> rangeIdsForChunk=newEltIds->findRangeIdForEachTuple(ranges);
824 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> idsInRrangeForChunk=newEltIds->findIdInRangeForEachTuple(ranges);
826 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmp=rangeIdsForChunk->duplicateEachTupleNTimes(nbi); rangeIdsForChunk->rearrange(nbi);
827 newGeoTypesPerChunk4->setPartOfValues1(tmp,(*it)->_tmp_work1-offset,(*it)->_tmp_work1+(*it)->_nval*nbi-offset,1,0,nbi,1);
829 newGeoTypesPerChunk[id]=rangeIdsForChunk; newGeoTypesPerChunk2[id]=rangeIdsForChunk;
830 newGeoTypesPerChunk_bis[id]=idsInRrangeForChunk; newGeoTypesPerChunk3[id]=idsInRrangeForChunk;
832 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> newGeoTypesEltIdsAllGather=DataArrayInt::Aggregate(newGeoTypesPerChunk2); newGeoTypesPerChunk.clear(); newGeoTypesPerChunk2.clear();
833 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> newGeoTypesEltIdsAllGather2=DataArrayInt::Aggregate(newGeoTypesPerChunk3); newGeoTypesPerChunk_bis.clear(); newGeoTypesPerChunk3.clear();
834 std::set<int> diffVals=newGeoTypesEltIdsAllGather->getDifferentValues();
835 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> renumEltIds=newGeoTypesEltIdsAllGather->buildPermArrPerLevel();
837 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> renumTupleIds=newGeoTypesPerChunk4->buildPermArrPerLevel();
839 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arrPart=arr->substr(offset,offset+szTuples);
840 arrPart->renumberInPlace(renumTupleIds->begin());
841 arr->setPartOfValues1(arrPart,offset,offset+szTuples,1,0,arrPart->getNumberOfComponents(),1);
843 std::set<int>::const_iterator idIt=diffVals.begin();
844 std::list<const MEDFileFieldPerMeshPerTypePerDisc *> li(entriesOnSameDisc.begin(),entriesOnSameDisc.end());
846 for(std::size_t i=0;i<diffVals.size();i++,idIt++)
848 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ids=newGeoTypesEltIdsAllGather->getIdsEqual(*idIt);
849 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> subIds=newGeoTypesEltIdsAllGather2->selectByTupleId(ids->begin(),ids->end());
850 int nbEntityElts=subIds->getNumberOfTuples();
852 MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> eltToAdd=MEDFileFieldPerMeshPerTypePerDisc::
853 NewObjectOnSameDiscThanPool(type,(INTERP_KERNEL::NormalizedCellType)newCode[3*(*idIt)],subIds,!subIds->isIdentity() || nbEntityElts!=newCode[3*(*idIt)+1],nbi,
857 result.push_back(eltToAdd);
858 offset2+=nbEntityElts*nbi;
860 ret=ret || li.empty();
865 * \param [in] typeF type of field of new chunk
866 * \param [in] geoType the geometric type of the chunk
867 * \param [in] idsOfMeshElt the entity ids of mesh (cells or nodes) of the new chunk.
868 * \param [in] isPfl specifies if a profile is requested regarding size of \a idsOfMeshElt and the number of such entities regarding underlying mesh.
869 * \param [in] nbi number of integration points
870 * \param [in] offset The offset in the **global array of data**.
871 * \param [in,out] entriesOnSameDisc the pool **on the same discretization** inside which it will be attempted to find an existing entry corresponding exactly
872 * to the new chunk to create.
873 * \param [in,out] glob the global shared info that will be requested for existing profiles or to append a new profile if needed.
874 * \param [out] notInExisting If false the return newly allocated entry is not coming from \a entriesOnSameDisc. If true the output comes from copy of \a entriesOnSameDisc
875 * and corresponding entry erased from \a entriesOnSameDisc.
876 * \return a newly allocated chunk
878 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerTypePerDisc::NewObjectOnSameDiscThanPool(TypeOfField typeF, INTERP_KERNEL::NormalizedCellType geoType, DataArrayInt *idsOfMeshElt,
879 bool isPfl, int nbi, int offset,
880 std::list< const MEDFileFieldPerMeshPerTypePerDisc *>& entriesOnSameDisc,
881 MEDFileFieldGlobsReal& glob,
882 bool ¬InExisting) throw(INTERP_KERNEL::Exception)
884 int nbMeshEntities=idsOfMeshElt->getNumberOfTuples();
885 std::list< const MEDFileFieldPerMeshPerTypePerDisc *>::iterator it=entriesOnSameDisc.begin();
886 for(;it!=entriesOnSameDisc.end();it++)
888 if(((INTERP_KERNEL::NormalizedCellType)(*it)->_loc_id)==geoType && (*it)->_nval==nbMeshEntities)
892 if((*it)->_profile.empty())
895 if(!(*it)->_profile.empty())
897 const DataArrayInt *pfl=glob.getProfile((*it)->_profile.c_str());
898 if(pfl->isEqualWithoutConsideringStr(*idsOfMeshElt))
904 if(it==entriesOnSameDisc.end())
907 MEDFileFieldPerMeshPerTypePerDisc *ret=new MEDFileFieldPerMeshPerTypePerDisc;
909 ret->_loc_id=(int)geoType;
910 ret->_nval=nbMeshEntities;
912 ret->_end=ret->_start+ret->_nval*nbi;
915 idsOfMeshElt->setName(glob.createNewNameOfPfl().c_str());
916 glob.appendProfile(idsOfMeshElt);
917 ret->_profile=idsOfMeshElt->getName();
919 //tony treatment of localization
925 MEDFileFieldPerMeshPerTypePerDisc *ret=MEDFileFieldPerMeshPerTypePerDisc::New(*(*it));
926 ret->_loc_id=(int)geoType;
927 ret->setNewStart(offset);
928 entriesOnSameDisc.erase(it);
934 MEDFileFieldPerMeshPerType *MEDFileFieldPerMeshPerType::NewOnRead(med_idt fid, MEDFileFieldPerMesh *fath, TypeOfField type, INTERP_KERNEL::NormalizedCellType geoType) throw(INTERP_KERNEL::Exception)
936 return new MEDFileFieldPerMeshPerType(fid,fath,type,geoType);
939 MEDFileFieldPerMeshPerType *MEDFileFieldPerMeshPerType::New(MEDFileFieldPerMesh *fath, INTERP_KERNEL::NormalizedCellType geoType) throw(INTERP_KERNEL::Exception)
941 return new MEDFileFieldPerMeshPerType(fath,geoType);
944 std::size_t MEDFileFieldPerMeshPerType::getHeapMemorySize() const
946 std::size_t ret=_field_pm_pt_pd.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc>);
947 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
948 ret+=(*it)->getHeapMemorySize();
952 MEDFileFieldPerMeshPerType *MEDFileFieldPerMeshPerType::deepCpy(MEDFileFieldPerMesh *father) const throw(INTERP_KERNEL::Exception)
954 MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerType> ret=new MEDFileFieldPerMeshPerType(*this);
957 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++,i++)
959 if((const MEDFileFieldPerMeshPerTypePerDisc *)*it)
960 ret->_field_pm_pt_pd[i]=(*it)->deepCpy((MEDFileFieldPerMeshPerType *)ret);
965 void MEDFileFieldPerMeshPerType::assignFieldNoProfile(int& start, int offset, int nbOfCells, const MEDCouplingFieldDouble *field, MEDFileFieldGlobsReal& glob) throw(INTERP_KERNEL::Exception)
967 std::vector<int> pos=addNewEntryIfNecessary(field,offset,nbOfCells);
968 for(std::vector<int>::const_iterator it=pos.begin();it!=pos.end();it++)
969 _field_pm_pt_pd[*it]->assignFieldNoProfile(start,offset,nbOfCells,field,glob);
973 * This method is the most general one. No optimization is done here.
974 * \param [in] multiTypePfl is the end user profile specified in high level API
975 * \param [in] idsInPfl is the selection into the \a multiTypePfl whole profile that corresponds to the current geometric type.
976 * \param [in] locIds is the profile needed to be created for MED file format. It can be null if all cells of current geometric type are fetched in \a multiTypePfl.
977 * \b WARNING if not null the MED file profile can be subdivided again in case of Gauss points.
978 * \param [in] nbOfEltsInWholeMesh nb of elts of type \a this->_geo_type in \b WHOLE mesh
979 * \param [in] mesh is the mesh coming from the MEDFileMesh instance in correspondance with the MEDFileField. The mesh inside the \a field is simply ignored.
981 void MEDFileFieldPerMeshPerType::assignFieldProfile(int& start, const DataArrayInt *multiTypePfl, const DataArrayInt *idsInPfl, DataArrayInt *locIds, int nbOfEltsInWholeMesh, const MEDCouplingFieldDouble *field, const MEDCouplingMesh *mesh, MEDFileFieldGlobsReal& glob) throw(INTERP_KERNEL::Exception)
983 std::vector<int> pos=addNewEntryIfNecessary(field,idsInPfl);
984 for(std::vector<int>::const_iterator it=pos.begin();it!=pos.end();it++)
985 _field_pm_pt_pd[*it]->assignFieldProfile(start,multiTypePfl,idsInPfl,locIds,nbOfEltsInWholeMesh,field,mesh,glob);
988 void MEDFileFieldPerMeshPerType::assignNodeFieldNoProfile(int& start, const MEDCouplingFieldDouble *field, MEDFileFieldGlobsReal& glob) throw(INTERP_KERNEL::Exception)
990 _field_pm_pt_pd.resize(1);
991 _field_pm_pt_pd[0]=MEDFileFieldPerMeshPerTypePerDisc::New(this,ON_NODES,-3);
992 _field_pm_pt_pd[0]->assignNodeFieldNoProfile(start,field,glob);
995 void MEDFileFieldPerMeshPerType::assignNodeFieldProfile(int& start, const DataArrayInt *pfl, const MEDCouplingFieldDouble *field, MEDFileFieldGlobsReal& glob) throw(INTERP_KERNEL::Exception)
997 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> pfl2=pfl->deepCpy();
999 _field_pm_pt_pd.resize(1);
1000 _field_pm_pt_pd[0]=MEDFileFieldPerMeshPerTypePerDisc::New(this,ON_NODES,-3);
1001 _field_pm_pt_pd[0]->assignFieldProfile(start,pfl,pfl2,pfl2,-1,field,0,glob);//mesh is not requested so 0 is send.
1004 std::vector<int> MEDFileFieldPerMeshPerType::addNewEntryIfNecessary(const MEDCouplingFieldDouble *field, int offset, int nbOfCells) throw(INTERP_KERNEL::Exception)
1006 TypeOfField type=field->getTypeOfField();
1007 if(type!=ON_GAUSS_PT)
1009 int locIdToFind=MEDFileFieldPerMeshPerTypePerDisc::ConvertType(type,0);
1010 int sz=_field_pm_pt_pd.size();
1012 for(int j=0;j<sz && !found;j++)
1014 if(_field_pm_pt_pd[j]->getLocId()==locIdToFind)
1016 _field_pm_pt_pd[j]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1022 _field_pm_pt_pd.resize(sz+1);
1023 _field_pm_pt_pd[sz]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1025 std::vector<int> ret(1,0);
1030 std::vector<int> ret2=addNewEntryIfNecessaryGauss(field,offset,nbOfCells);
1031 int sz2=ret2.size();
1032 std::vector<int> ret3(sz2);
1034 for(int i=0;i<sz2;i++)
1036 int sz=_field_pm_pt_pd.size();
1037 int locIdToFind=ret2[i];
1039 for(int j=0;j<sz && !found;j++)
1041 if(_field_pm_pt_pd[j]->getLocId()==locIdToFind)
1043 _field_pm_pt_pd[j]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1050 _field_pm_pt_pd.resize(sz+1);
1051 _field_pm_pt_pd[sz]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1059 std::vector<int> MEDFileFieldPerMeshPerType::addNewEntryIfNecessaryGauss(const MEDCouplingFieldDouble *field, int offset, int nbOfCells) throw(INTERP_KERNEL::Exception)
1061 const MEDCouplingFieldDiscretization *disc=field->getDiscretization();
1062 const MEDCouplingFieldDiscretizationGauss *disc2=dynamic_cast<const MEDCouplingFieldDiscretizationGauss *>(disc);
1064 throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : invalid call to this method ! Internal Error !");
1065 const DataArrayInt *da=disc2->getArrayOfDiscIds();
1066 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da2=da->selectByTupleId2(offset,offset+nbOfCells,1);
1067 std::set<int> retTmp=da2->getDifferentValues();
1068 if(retTmp.find(-1)!=retTmp.end())
1069 throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : some cells have no dicretization description !");
1070 std::vector<int> ret(retTmp.begin(),retTmp.end());
1074 std::vector<int> MEDFileFieldPerMeshPerType::addNewEntryIfNecessary(const MEDCouplingFieldDouble *field, const DataArrayInt *subCells) throw(INTERP_KERNEL::Exception)
1076 TypeOfField type=field->getTypeOfField();
1077 if(type!=ON_GAUSS_PT)
1079 int locIdToFind=MEDFileFieldPerMeshPerTypePerDisc::ConvertType(type,0);
1080 int sz=_field_pm_pt_pd.size();
1082 for(int j=0;j<sz && !found;j++)
1084 if(_field_pm_pt_pd[j]->getLocId()==locIdToFind)
1086 _field_pm_pt_pd[j]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1092 _field_pm_pt_pd.resize(sz+1);
1093 _field_pm_pt_pd[sz]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1095 std::vector<int> ret(1,0);
1100 std::vector<int> ret2=addNewEntryIfNecessaryGauss(field,subCells);
1101 int sz2=ret2.size();
1102 std::vector<int> ret3(sz2);
1104 for(int i=0;i<sz2;i++)
1106 int sz=_field_pm_pt_pd.size();
1107 int locIdToFind=ret2[i];
1109 for(int j=0;j<sz && !found;j++)
1111 if(_field_pm_pt_pd[j]->getLocId()==locIdToFind)
1113 _field_pm_pt_pd[j]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1120 _field_pm_pt_pd.resize(sz+1);
1121 _field_pm_pt_pd[sz]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1129 std::vector<int> MEDFileFieldPerMeshPerType::addNewEntryIfNecessaryGauss(const MEDCouplingFieldDouble *field, const DataArrayInt *subCells) throw(INTERP_KERNEL::Exception)
1131 const MEDCouplingFieldDiscretization *disc=field->getDiscretization();
1132 const MEDCouplingFieldDiscretizationGauss *disc2=dynamic_cast<const MEDCouplingFieldDiscretizationGauss *>(disc);
1134 throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : invalid call to this method ! Internal Error !");
1135 const DataArrayInt *da=disc2->getArrayOfDiscIds();
1136 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da2=da->selectByTupleIdSafe(subCells->getConstPointer(),subCells->getConstPointer()+subCells->getNumberOfTuples());
1137 std::set<int> retTmp=da2->getDifferentValues();
1138 if(retTmp.find(-1)!=retTmp.end())
1139 throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : some cells have no dicretization description !");
1140 std::vector<int> ret(retTmp.begin(),retTmp.end());
1144 const MEDFileFieldPerMesh *MEDFileFieldPerMeshPerType::getFather() const
1149 void MEDFileFieldPerMeshPerType::getDimension(int& dim) const
1151 const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1152 int curDim=(int)cm.getDimension();
1153 dim=std::max(dim,curDim);
1156 void MEDFileFieldPerMeshPerType::fillTypesOfFieldAvailable(std::set<TypeOfField>& types) const throw(INTERP_KERNEL::Exception)
1158 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1160 (*it)->fillTypesOfFieldAvailable(types);
1164 void MEDFileFieldPerMeshPerType::fillFieldSplitedByType(std::vector< std::pair<int,int> >& dads, std::vector<TypeOfField>& types, std::vector<std::string>& pfls, std::vector<std::string>& locs) const throw(INTERP_KERNEL::Exception)
1166 int sz=_field_pm_pt_pd.size();
1167 dads.resize(sz); types.resize(sz); pfls.resize(sz); locs.resize(sz);
1168 for(int i=0;i<sz;i++)
1170 _field_pm_pt_pd[i]->getCoarseData(types[i],dads[i],pfls[i],locs[i]);
1174 int MEDFileFieldPerMeshPerType::getIteration() const
1176 return _father->getIteration();
1179 int MEDFileFieldPerMeshPerType::getOrder() const
1181 return _father->getOrder();
1184 double MEDFileFieldPerMeshPerType::getTime() const
1186 return _father->getTime();
1189 std::string MEDFileFieldPerMeshPerType::getName() const
1191 return _father->getName();
1194 std::string MEDFileFieldPerMeshPerType::getMeshName() const
1196 return _father->getMeshName();
1199 void MEDFileFieldPerMeshPerType::simpleRepr(int bkOffset, std::ostream& oss, int id) const
1201 const char startLine[]=" ## ";
1202 std::string startLine2(bkOffset,' ');
1203 std::string startLine3(startLine2);
1204 startLine3+=startLine;
1205 if(_geo_type!=INTERP_KERNEL::NORM_ERROR)
1207 const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1208 oss << startLine3 << "Entry geometry type #" << id << " is lying on geometry types " << cm.getRepr() << "." << std::endl;
1211 oss << startLine3 << "Entry geometry type #" << id << " is lying on NODES." << std::endl;
1212 oss << startLine3 << "Entry is defined on " << _field_pm_pt_pd.size() << " localizations." << std::endl;
1214 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++,i++)
1216 const MEDFileFieldPerMeshPerTypePerDisc *cur=(*it);
1218 cur->simpleRepr(bkOffset,oss,i);
1221 oss << startLine2 << " ## " << "Localization #" << i << " is empty !" << std::endl;
1226 void MEDFileFieldPerMeshPerType::getSizes(int& globalSz, int& nbOfEntries) const
1228 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1230 globalSz+=(*it)->getNumberOfTuples();
1232 nbOfEntries+=(int)_field_pm_pt_pd.size();
1235 INTERP_KERNEL::NormalizedCellType MEDFileFieldPerMeshPerType::getGeoType() const
1241 int MEDFileFieldPerMeshPerType::getNumberOfComponents() const
1243 return _father->getNumberOfComponents();
1246 DataArrayDouble *MEDFileFieldPerMeshPerType::getArray()
1248 return _father->getArray();
1251 const DataArrayDouble *MEDFileFieldPerMeshPerType::getArray() const
1253 const MEDFileFieldPerMesh *fath=_father;
1254 return fath->getArray();
1257 const std::vector<std::string>& MEDFileFieldPerMeshPerType::getInfo() const
1259 return _father->getInfo();
1262 std::vector<std::string> MEDFileFieldPerMeshPerType::getPflsReallyUsed() const
1264 std::vector<std::string> ret;
1265 std::set<std::string> ret2;
1266 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1268 std::string tmp=(*it1)->getProfile();
1270 if(ret2.find(tmp)==ret2.end())
1279 std::vector<std::string> MEDFileFieldPerMeshPerType::getLocsReallyUsed() const
1281 std::vector<std::string> ret;
1282 std::set<std::string> ret2;
1283 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1285 std::string tmp=(*it1)->getLocalization();
1286 if(!tmp.empty() && tmp!=MED_GAUSS_ELNO)
1287 if(ret2.find(tmp)==ret2.end())
1296 std::vector<std::string> MEDFileFieldPerMeshPerType::getPflsReallyUsedMulti() const
1298 std::vector<std::string> ret;
1299 std::set<std::string> ret2;
1300 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1302 std::string tmp=(*it1)->getProfile();
1309 std::vector<std::string> MEDFileFieldPerMeshPerType::getLocsReallyUsedMulti() const
1311 std::vector<std::string> ret;
1312 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1314 std::string tmp=(*it1)->getLocalization();
1315 if(!tmp.empty() && tmp!=MED_GAUSS_ELNO)
1321 void MEDFileFieldPerMeshPerType::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
1323 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1324 (*it1)->changePflsRefsNamesGen(mapOfModif);
1327 void MEDFileFieldPerMeshPerType::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
1329 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1330 (*it1)->changeLocsRefsNamesGen(mapOfModif);
1333 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerType::getLeafGivenLocId(int locId) throw(INTERP_KERNEL::Exception)
1335 if(_field_pm_pt_pd.empty())
1337 const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1338 std::ostringstream oss; oss << "MEDFileFieldPerMeshPerType::getLeafGivenLocId : no localizations for geotype \"" << cm.getRepr() << "\" !";
1339 throw INTERP_KERNEL::Exception(oss.str().c_str());
1341 if(locId>=0 && locId<(int)_field_pm_pt_pd.size())
1342 return _field_pm_pt_pd[locId];
1343 const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1344 std::ostringstream oss2; oss2 << "MEDFileFieldPerMeshPerType::getLeafGivenLocId : no such locId available (" << locId;
1345 oss2 << ") for geometric type \"" << cm.getRepr() << "\" It should be in [0," << _field_pm_pt_pd.size() << ") !";
1346 throw INTERP_KERNEL::Exception(oss2.str().c_str());
1347 return static_cast<MEDFileFieldPerMeshPerTypePerDisc*>(0);
1350 const MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerType::getLeafGivenLocId(int locId) const throw(INTERP_KERNEL::Exception)
1352 if(_field_pm_pt_pd.empty())
1354 const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1355 std::ostringstream oss; oss << "MEDFileFieldPerMeshPerType::getLeafGivenLocId : no localizations for geotype \"" << cm.getRepr() << "\" !";
1356 throw INTERP_KERNEL::Exception(oss.str().c_str());
1358 if(locId>=0 && locId<(int)_field_pm_pt_pd.size())
1359 return _field_pm_pt_pd[locId];
1360 const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1361 std::ostringstream oss2; oss2 << "MEDFileFieldPerMeshPerType::getLeafGivenLocId : no such locId available (" << locId;
1362 oss2 << ") for geometric type \"" << cm.getRepr() << "\" It should be in [0," << _field_pm_pt_pd.size() << ") !";
1363 throw INTERP_KERNEL::Exception(oss2.str().c_str());
1364 return static_cast<const MEDFileFieldPerMeshPerTypePerDisc*>(0);
1367 void MEDFileFieldPerMeshPerType::getFieldAtLevel(int meshDim, TypeOfField type, const MEDFileFieldGlobsReal *glob, std::vector< std::pair<int,int> >& dads, std::vector<const DataArrayInt *>& pfls, std::vector<int>& locs, std::vector<INTERP_KERNEL::NormalizedCellType>& geoTypes) const
1369 if(_geo_type!=INTERP_KERNEL::NORM_ERROR)
1371 const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1372 if(meshDim!=(int)cm.getDimension())
1375 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1376 (*it)->getFieldAtLevel(type,glob,dads,pfls,locs,geoTypes);
1379 void MEDFileFieldPerMeshPerType::fillValues(int& startEntryId, std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
1382 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++,i++)
1384 (*it)->fillValues(i,startEntryId,entries);
1388 void MEDFileFieldPerMeshPerType::setLeaves(const std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerTypePerDisc > >& leaves) throw(INTERP_KERNEL::Exception)
1390 _field_pm_pt_pd=leaves;
1391 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1392 (*it)->setFather(this);
1395 MEDFileFieldPerMeshPerType::MEDFileFieldPerMeshPerType(MEDFileFieldPerMesh *fath, INTERP_KERNEL::NormalizedCellType geoType) throw(INTERP_KERNEL::Exception):_father(fath),_geo_type(geoType)
1399 MEDFileFieldPerMeshPerType::MEDFileFieldPerMeshPerType(med_idt fid, MEDFileFieldPerMesh *fath, TypeOfField type, INTERP_KERNEL::NormalizedCellType geoType) throw(INTERP_KERNEL::Exception):_father(fath),_geo_type(geoType)
1401 INTERP_KERNEL::AutoPtr<char> pflName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
1402 INTERP_KERNEL::AutoPtr<char> locName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
1403 med_geometry_type mgeoti;
1404 med_entity_type menti=ConvertIntoMEDFileType(type,geoType,mgeoti);
1405 int nbProfiles=MEDfieldnProfile(fid,getName().c_str(),getIteration(),getOrder(),menti,mgeoti,pflName,locName);
1406 _field_pm_pt_pd.resize(nbProfiles);
1407 for(int i=0;i<nbProfiles;i++)
1409 _field_pm_pt_pd[i]=MEDFileFieldPerMeshPerTypePerDisc::NewOnRead(this,type,i+1);
1413 void MEDFileFieldPerMeshPerType::prepareLoading(med_idt fid, int &start) throw(INTERP_KERNEL::Exception)
1416 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++,pflId++)
1418 (*it)->prepareLoading(fid,pflId+1,start);
1422 void MEDFileFieldPerMeshPerType::finishLoading(med_idt fid, int ft) throw(INTERP_KERNEL::Exception)
1425 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++,pflId++)
1427 (*it)->finishLoading(fid,pflId+1,ft);
1431 void MEDFileFieldPerMeshPerType::writeLL(med_idt fid) const throw(INTERP_KERNEL::Exception)
1433 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1435 (*it)->copyOptionsFrom(*this);
1436 (*it)->writeLL(fid);
1440 med_entity_type MEDFileFieldPerMeshPerType::ConvertIntoMEDFileType(TypeOfField ikType, INTERP_KERNEL::NormalizedCellType ikGeoType, med_geometry_type& medfGeoType)
1445 medfGeoType=typmai3[(int)ikGeoType];
1448 medfGeoType=MED_NONE;
1451 medfGeoType=typmai3[(int)ikGeoType];
1452 return MED_NODE_ELEMENT;
1454 medfGeoType=typmai3[(int)ikGeoType];
1457 throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerType::ConvertIntoMEDFileType : unexpected entity type ! internal error");
1459 return MED_UNDEF_ENTITY_TYPE;
1462 MEDFileFieldPerMesh *MEDFileFieldPerMesh::NewOnRead(med_idt fid, MEDFileField1TSWithoutSDA *fath, int meshCsit, int meshIteration, int meshOrder) throw(INTERP_KERNEL::Exception)
1464 return new MEDFileFieldPerMesh(fid,fath,meshCsit,meshIteration,meshOrder);
1467 MEDFileFieldPerMesh *MEDFileFieldPerMesh::New(MEDFileField1TSWithoutSDA *fath, const MEDCouplingMesh *mesh)
1469 return new MEDFileFieldPerMesh(fath,mesh);
1472 std::size_t MEDFileFieldPerMesh::getHeapMemorySize() const
1474 std::size_t ret=_mesh_name.capacity()+_field_pm_pt.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType >);
1475 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1476 if((const MEDFileFieldPerMeshPerType *)*it)
1477 ret+=(*it)->getHeapMemorySize();
1481 MEDFileFieldPerMesh *MEDFileFieldPerMesh::deepCpy(MEDFileField1TSWithoutSDA *father) const throw(INTERP_KERNEL::Exception)
1483 MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > ret=new MEDFileFieldPerMesh(*this);
1484 ret->_father=father;
1486 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++,i++)
1488 if((const MEDFileFieldPerMeshPerType *)*it)
1489 ret->_field_pm_pt[i]=(*it)->deepCpy((MEDFileFieldPerMesh *)(ret));
1494 void MEDFileFieldPerMesh::simpleRepr(int bkOffset, std::ostream& oss, int id) const
1496 std::string startLine(bkOffset,' ');
1497 oss << startLine << "## Field part (" << id << ") lying on mesh \"" << _mesh_name << "\", Mesh iteration=" << _mesh_iteration << ". Mesh order=" << _mesh_order << "." << std::endl;
1498 oss << startLine << "## Field is defined on " << _field_pm_pt.size() << " types." << std::endl;
1500 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++,i++)
1502 const MEDFileFieldPerMeshPerType *cur=*it;
1504 cur->simpleRepr(bkOffset,oss,i);
1507 oss << startLine << " ## Entry geometry type #" << i << " is empty !" << std::endl;
1512 void MEDFileFieldPerMesh::copyTinyInfoFrom(const MEDCouplingMesh *mesh) throw(INTERP_KERNEL::Exception)
1514 _mesh_name=mesh->getName();
1515 mesh->getTime(_mesh_iteration,_mesh_order);
1518 void MEDFileFieldPerMesh::assignFieldNoProfileNoRenum(int& start, const std::vector<int>& code, const MEDCouplingFieldDouble *field, MEDFileFieldGlobsReal& glob) throw(INTERP_KERNEL::Exception)
1520 int nbOfTypes=code.size()/3;
1522 for(int i=0;i<nbOfTypes;i++)
1524 INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)code[3*i];
1525 int nbOfCells=code[3*i+1];
1526 int pos=addNewEntryIfNecessary(type);
1527 _field_pm_pt[pos]->assignFieldNoProfile(start,offset,nbOfCells,field,glob);
1533 * This method is the most general one. No optimization is done here.
1534 * \param [in] multiTypePfl is the end user profile specified in high level API
1535 * \param [in] code is the code of \a mesh[multiTypePfl] mesh. It is of size of number of different geometric types into \a mesh[multiTypePfl].
1536 * \param [in] code2 is the code of the \b WHOLE mesh on the same level. So all types in \a code are in \a code2.
1537 * \param [in] idsInPflPerType is the selection into the \a multiTypePfl whole profile that corresponds to the given geometric type. This vector is always 3 times smaller than \a code.
1538 * \param [in] idsPerType is a vector containing the profiles needed to be created for MED file format. \b WARNING these processed MED file profiles can be subdivided again in case of Gauss points.
1539 * \param [in] mesh is the mesh coming from the MEDFileMesh instance in correspondance with the MEDFileField. The mesh inside the \a field is simply ignored.
1541 void MEDFileFieldPerMesh::assignFieldProfile(int& start, const DataArrayInt *multiTypePfl, const std::vector<int>& code, const std::vector<int>& code2, const std::vector<DataArrayInt *>& idsInPflPerType, const std::vector<DataArrayInt *>& idsPerType, const MEDCouplingFieldDouble *field, const MEDCouplingMesh *mesh, MEDFileFieldGlobsReal& glob) throw(INTERP_KERNEL::Exception)
1543 int nbOfTypes=code.size()/3;
1544 for(int i=0;i<nbOfTypes;i++)
1546 INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)code[3*i];
1547 int pos=addNewEntryIfNecessary(type);
1548 DataArrayInt *pfl=0;
1550 pfl=idsPerType[code[3*i+2]];
1551 int nbOfTupes2=code2.size()/3;
1553 for(;found<nbOfTupes2;found++)
1554 if(code[3*i]==code2[3*found])
1556 if(found==nbOfTupes2)
1557 throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::assignFieldProfile : internal problem ! Should never happen ! Please report bug to anthony.geay@cea.fr !");
1558 _field_pm_pt[pos]->assignFieldProfile(start,multiTypePfl,idsInPflPerType[i],pfl,code2[3*found+1],field,mesh,glob);
1562 void MEDFileFieldPerMesh::assignNodeFieldNoProfile(int& start, const MEDCouplingFieldDouble *field, MEDFileFieldGlobsReal& glob) throw(INTERP_KERNEL::Exception)
1564 int pos=addNewEntryIfNecessary(INTERP_KERNEL::NORM_ERROR);
1565 _field_pm_pt[pos]->assignNodeFieldNoProfile(start,field,glob);
1568 void MEDFileFieldPerMesh::assignNodeFieldProfile(int& start, const DataArrayInt *pfl, const MEDCouplingFieldDouble *field, MEDFileFieldGlobsReal& glob) throw(INTERP_KERNEL::Exception)
1570 int pos=addNewEntryIfNecessary(INTERP_KERNEL::NORM_ERROR);
1571 _field_pm_pt[pos]->assignNodeFieldProfile(start,pfl,field,glob);
1574 void MEDFileFieldPerMesh::prepareLoading(med_idt fid, int& start) throw(INTERP_KERNEL::Exception)
1576 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1577 (*it)->prepareLoading(fid,start);
1580 void MEDFileFieldPerMesh::finishLoading(med_idt fid, int ft) throw(INTERP_KERNEL::Exception)
1582 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1583 (*it)->finishLoading(fid,ft);
1586 void MEDFileFieldPerMesh::writeLL(med_idt fid) const throw(INTERP_KERNEL::Exception)
1588 int nbOfTypes=_field_pm_pt.size();
1589 for(int i=0;i<nbOfTypes;i++)
1591 _field_pm_pt[i]->copyOptionsFrom(*this);
1592 _field_pm_pt[i]->writeLL(fid);
1596 void MEDFileFieldPerMesh::getDimension(int& dim) const
1598 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1599 (*it)->getDimension(dim);
1602 void MEDFileFieldPerMesh::fillTypesOfFieldAvailable(std::set<TypeOfField>& types) const throw(INTERP_KERNEL::Exception)
1604 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1605 (*it)->fillTypesOfFieldAvailable(types);
1608 std::vector< std::vector< std::pair<int,int> > > MEDFileFieldPerMesh::getFieldSplitedByType(std::vector<INTERP_KERNEL::NormalizedCellType>& types, std::vector< std::vector<TypeOfField> >& typesF, std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> > & locs) const throw(INTERP_KERNEL::Exception)
1610 int sz=_field_pm_pt.size();
1611 std::vector< std::vector<std::pair<int,int> > > ret(sz);
1612 types.resize(sz); typesF.resize(sz); pfls.resize(sz); locs.resize(sz);
1613 for(int i=0;i<sz;i++)
1615 types[i]=_field_pm_pt[i]->getGeoType();
1616 _field_pm_pt[i]->fillFieldSplitedByType(ret[i],typesF[i],pfls[i],locs[i]);
1621 double MEDFileFieldPerMesh::getTime() const
1624 return _father->getTime(tmp1,tmp2);
1627 int MEDFileFieldPerMesh::getIteration() const
1629 return _father->getIteration();
1632 const std::string& MEDFileFieldPerMesh::getDtUnit() const
1634 return _father->getDtUnit();
1637 int MEDFileFieldPerMesh::getOrder() const
1639 return _father->getOrder();
1642 std::string MEDFileFieldPerMesh::getName() const
1644 return _father->getName();
1647 int MEDFileFieldPerMesh::getNumberOfComponents() const
1649 return _father->getNumberOfComponents();
1652 DataArrayDouble *MEDFileFieldPerMesh::getArray()
1654 return _father->getOrCreateAndGetArray();
1657 const DataArrayDouble *MEDFileFieldPerMesh::getArray() const
1659 const MEDFileField1TSWithoutSDA *fath=_father;
1660 return fath->getOrCreateAndGetArray();
1663 const std::vector<std::string>& MEDFileFieldPerMesh::getInfo() const
1665 return _father->getInfo();
1669 * type,geoTypes,dads,pfls,locs are input parameters. They should have the same size.
1670 * Before the call of this method 'geoTypes','dads','pfls','locs' must be reorganized so that types in geoTypes are contiguous and ordered following typmai2 array.
1671 * It returns 2 output vectors :
1672 * - 'code' of size 3*sz where sz is the number of different values into 'geoTypes'
1673 * - 'notNullPfls' contains sz2 values that are extracted from 'pfls' in which null profiles have been removed.
1674 * 'code' and 'notNullPfls' are in MEDCouplingUMesh::checkTypeConsistencyAndContig format.
1676 void MEDFileFieldPerMesh::SortArraysPerType(const MEDFileFieldGlobsReal *glob, TypeOfField type, const std::vector<INTERP_KERNEL::NormalizedCellType>& geoTypes, const std::vector< std::pair<int,int> >& dads, const std::vector<const DataArrayInt *>& pfls, const std::vector<int>& locs, std::vector<int>& code, std::vector<DataArrayInt *>& notNullPfls)
1678 int notNullPflsSz=0;
1679 int nbOfArrs=geoTypes.size();
1680 for(int i=0;i<nbOfArrs;i++)
1683 std::set<INTERP_KERNEL::NormalizedCellType> geoTypes3(geoTypes.begin(),geoTypes.end());
1684 int nbOfDiffGeoTypes=geoTypes3.size();
1685 code.resize(3*nbOfDiffGeoTypes);
1686 notNullPfls.resize(notNullPflsSz);
1689 for(int i=0;i<nbOfDiffGeoTypes;i++)
1692 INTERP_KERNEL::NormalizedCellType refType=geoTypes[j];
1693 std::vector<const DataArrayInt *> notNullTmp;
1695 notNullTmp.push_back(pfls[j]);
1697 for(;j<nbOfArrs;j++)
1698 if(geoTypes[j]==refType)
1701 notNullTmp.push_back(pfls[j]);
1705 std::vector< std::pair<int,int> > tmpDads(dads.begin()+startZone,dads.begin()+j);
1706 std::vector<const DataArrayInt *> tmpPfls(pfls.begin()+startZone,pfls.begin()+j);
1707 std::vector<int> tmpLocs(locs.begin()+startZone,locs.begin()+j);
1708 code[3*i]=(int)refType;
1709 std::vector<INTERP_KERNEL::NormalizedCellType> refType2(1,refType);
1710 code[3*i+1]=ComputeNbOfElems(glob,type,refType2,tmpDads,tmpLocs);
1711 if(notNullTmp.empty())
1715 notNullPfls[notNullPflsSz]=DataArrayInt::Aggregate(notNullTmp);
1716 code[3*i+2]=notNullPflsSz++;
1722 * 'dads' 'geoTypes' and 'locs' are input parameters that should have same size sz. sz should be >=1.
1724 int MEDFileFieldPerMesh::ComputeNbOfElems(const MEDFileFieldGlobsReal *glob, TypeOfField type, const std::vector<INTERP_KERNEL::NormalizedCellType>& geoTypes, const std::vector< std::pair<int,int> >& dads, const std::vector<int>& locs) throw(INTERP_KERNEL::Exception)
1728 for(int i=0;i<sz;i++)
1732 if(type!=ON_GAUSS_NE)
1733 ret+=dads[i].second-dads[i].first;
1736 const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(geoTypes[i]);
1737 ret+=(dads[i].second-dads[i].first)/cm.getNumberOfNodes();
1742 int nbOfGaussPtPerCell=glob->getNbOfGaussPtPerCell(locs[i]);
1743 ret+=(dads[i].second-dads[i].first)/nbOfGaussPtPerCell;
1749 std::vector<std::string> MEDFileFieldPerMesh::getPflsReallyUsed() const
1751 std::vector<std::string> ret;
1752 std::set<std::string> ret2;
1753 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1755 std::vector<std::string> tmp=(*it)->getPflsReallyUsed();
1756 for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
1757 if(ret2.find(*it2)==ret2.end())
1759 ret.push_back(*it2);
1766 std::vector<std::string> MEDFileFieldPerMesh::getPflsReallyUsedMulti() const
1768 std::vector<std::string> ret;
1769 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1771 std::vector<std::string> tmp=(*it)->getPflsReallyUsedMulti();
1772 ret.insert(ret.end(),tmp.begin(),tmp.end());
1777 std::vector<std::string> MEDFileFieldPerMesh::getLocsReallyUsed() const
1779 std::vector<std::string> ret;
1780 std::set<std::string> ret2;
1781 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1783 std::vector<std::string> tmp=(*it)->getLocsReallyUsed();
1784 for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
1785 if(ret2.find(*it2)==ret2.end())
1787 ret.push_back(*it2);
1794 std::vector<std::string> MEDFileFieldPerMesh::getLocsReallyUsedMulti() const
1796 std::vector<std::string> ret;
1797 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1799 std::vector<std::string> tmp=(*it)->getLocsReallyUsedMulti();
1800 ret.insert(ret.end(),tmp.begin(),tmp.end());
1805 bool MEDFileFieldPerMesh::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab) throw(INTERP_KERNEL::Exception)
1807 for(std::vector< std::pair<std::string,std::string> >::const_iterator it=modifTab.begin();it!=modifTab.end();it++)
1809 if((*it).first==_mesh_name)
1811 _mesh_name=(*it).second;
1818 bool MEDFileFieldPerMesh::renumberEntitiesLyingOnMesh(const char *meshName, const std::vector<int>& oldCode, const std::vector<int>& newCode, const DataArrayInt *renumO2N,
1819 MEDFileFieldGlobsReal& glob) throw(INTERP_KERNEL::Exception)
1821 if(_mesh_name!=meshName)
1823 std::set<INTERP_KERNEL::NormalizedCellType> typesToKeep;
1824 for(std::size_t i=0;i<oldCode.size()/3;i++) typesToKeep.insert((INTERP_KERNEL::NormalizedCellType)oldCode[3*i]);
1825 std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > > entries;
1826 std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> entriesKept;
1827 std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> otherEntries;
1828 DataArrayDouble *arr=getUndergroundDataArrayExt(entries);
1831 throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::renumberEntitiesLyingOnMesh : DataArrayDouble storing values of field is null !");
1832 for(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >::const_iterator it=entries.begin();it!=entries.end();it++)
1834 if(typesToKeep.find((*it).first.first)!=typesToKeep.end())
1836 entriesKept.push_back(getLeafGivenTypeAndLocId((*it).first.first,(*it).first.second));
1837 sz+=(*it).second.second-(*it).second.first;
1840 otherEntries.push_back(getLeafGivenTypeAndLocId((*it).first.first,(*it).first.second));
1842 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> renumDefrag=DataArrayInt::New(); renumDefrag->alloc(arr->getNumberOfTuples(),1); renumDefrag->fillWithZero();
1843 ////////////////////
1844 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> explicitIdsOldInMesh=DataArrayInt::New(); explicitIdsOldInMesh->alloc(sz,1);//sz is a majorant of the real size. A realloc will be done after
1845 int *workI2=explicitIdsOldInMesh->getPointer();
1846 int sz1=0,sz2=0,sid=1;
1847 std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> > entriesKeptML=MEDFileFieldPerMeshPerTypePerDisc::SplitPerDiscretization(entriesKept);
1848 // std::vector<int> tupleIdOfStartOfNewChuncksV(entriesKeptML.size());
1849 for(std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> >::const_iterator itL1=entriesKeptML.begin();itL1!=entriesKeptML.end();itL1++,sid++)
1851 // tupleIdOfStartOfNewChuncksV[sid-1]=sz2;
1852 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> explicitIdsOldInArr=DataArrayInt::New(); explicitIdsOldInArr->alloc(sz,1);
1853 int *workI=explicitIdsOldInArr->getPointer();
1854 for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator itL2=(*itL1).begin();itL2!=(*itL1).end();itL2++)
1856 int delta1=(*itL2)->fillTupleIds(workI); workI+=delta1; sz1+=delta1;
1857 (*itL2)->setLocId(sz2);
1858 (*itL2)->_tmp_work1=(*itL2)->getStart();
1859 int delta2=(*itL2)->fillEltIdsFromCode(sz2,oldCode,glob,workI2); workI2+=delta2; sz2+=delta2;
1861 renumDefrag->setPartOfValuesSimple3(sid,explicitIdsOldInArr->begin(),explicitIdsOldInArr->end(),0,1,1);
1863 explicitIdsOldInMesh->reAlloc(sz2);
1864 int tupleIdOfStartOfNewChuncks=arr->getNumberOfTuples()-sz2;
1865 ////////////////////
1866 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> permArrDefrag=renumDefrag->buildPermArrPerLevel(); renumDefrag=0;
1867 // perform redispatching of non concerned MEDFileFieldPerMeshPerTypePerDisc
1868 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> > otherEntriesNew;
1869 for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=otherEntries.begin();it!=otherEntries.end();it++)
1871 otherEntriesNew.push_back(MEDFileFieldPerMeshPerTypePerDisc::New(*(*it)));
1872 otherEntriesNew.back()->setNewStart(permArrDefrag->getIJ((*it)->getStart(),0));
1873 otherEntriesNew.back()->setLocId((*it)->getGeoType());
1875 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> > entriesKeptNew;
1876 std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> entriesKeptNew2;
1877 for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=entriesKept.begin();it!=entriesKept.end();it++)
1879 MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> elt=MEDFileFieldPerMeshPerTypePerDisc::New(*(*it));
1880 int newStart=elt->getLocId();
1881 elt->setLocId((*it)->getGeoType());
1882 elt->setNewStart(newStart);
1883 elt->_tmp_work1=permArrDefrag->getIJ(elt->_tmp_work1,0);
1884 entriesKeptNew.push_back(elt);
1885 entriesKeptNew2.push_back(elt);
1887 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr2=arr->renumber(permArrDefrag->getConstPointer());
1888 // perform redispatching of concerned MEDFileFieldPerMeshPerTypePerDisc -> values are in arr2
1889 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> explicitIdsNewInMesh=renumO2N->selectByTupleId(explicitIdsOldInMesh->begin(),explicitIdsOldInMesh->end());
1890 std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> > entriesKeptPerDisc=MEDFileFieldPerMeshPerTypePerDisc::SplitPerDiscretization(entriesKeptNew2);
1892 for(std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> >::const_iterator it4=entriesKeptPerDisc.begin();it4!=entriesKeptPerDisc.end();it4++)
1895 /*for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator itL2=(*it4).begin();itL2!=(*it4).end();itL2++)
1897 MEDFileFieldPerMeshPerTypePerDisc *curNC=const_cast<MEDFileFieldPerMeshPerTypePerDisc *>(*itL2);
1898 curNC->setNewStart(permArrDefrag->getIJ((*itL2)->getStart(),0)-tupleIdOfStartOfNewChuncks+tupleIdOfStartOfNewChuncksV[sid]);
1900 ret=MEDFileFieldPerMeshPerTypePerDisc::RenumberChunks(tupleIdOfStartOfNewChuncks,*it4,explicitIdsNewInMesh,newCode,
1901 glob,arr2,otherEntriesNew) || ret;
1905 // Assign new dispatching
1906 assignNewLeaves(otherEntriesNew);
1907 arr->cpyFrom(*arr2);
1911 void MEDFileFieldPerMesh::assignNewLeaves(const std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerTypePerDisc > >& leaves) throw(INTERP_KERNEL::Exception)
1913 std::map<INTERP_KERNEL::NormalizedCellType,std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerTypePerDisc> > > types;
1914 for( std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerTypePerDisc > >::const_iterator it=leaves.begin();it!=leaves.end();it++)
1915 types[(INTERP_KERNEL::NormalizedCellType)(*it)->getLocId()].push_back(*it);
1917 std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > > fieldPmPt(types.size());
1918 std::map<INTERP_KERNEL::NormalizedCellType,std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerTypePerDisc> > >::const_iterator it1=types.begin();
1919 std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it2=fieldPmPt.begin();
1920 for(;it1!=types.end();it1++,it2++)
1922 MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerType> elt=MEDFileFieldPerMeshPerType::New(this,(INTERP_KERNEL::NormalizedCellType)((*it1).second[0]->getLocId()));
1923 elt->setLeaves((*it1).second);
1926 _field_pm_pt=fieldPmPt;
1929 void MEDFileFieldPerMesh::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
1931 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1932 (*it)->changePflsRefsNamesGen(mapOfModif);
1935 void MEDFileFieldPerMesh::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
1937 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1938 (*it)->changeLocsRefsNamesGen(mapOfModif);
1942 * \param [in] mesh is the whole mesh
1944 MEDCouplingFieldDouble *MEDFileFieldPerMesh::getFieldOnMeshAtLevel(TypeOfField type, const MEDFileFieldGlobsReal *glob, const MEDCouplingMesh *mesh, bool& isPfl) const throw(INTERP_KERNEL::Exception)
1946 if(_field_pm_pt.empty())
1947 throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getFieldOnMeshAtLevel : no types field set !");
1949 std::vector< std::pair<int,int> > dads;
1950 std::vector<const DataArrayInt *> pfls;
1951 std::vector<DataArrayInt *> notNullPflsPerGeoType;
1952 std::vector<int> locs,code;
1953 std::vector<INTERP_KERNEL::NormalizedCellType> geoTypes;
1954 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1955 (*it)->getFieldAtLevel(mesh->getMeshDimension(),type,glob,dads,pfls,locs,geoTypes);
1957 SortArraysPerType(glob,type,geoTypes,dads,pfls,locs,code,notNullPflsPerGeoType);
1960 std::ostringstream oss; oss << "MEDFileFieldPerMesh::getFieldOnMeshAtLevel : " << "The field \"" << getName() << "\" exists but not with such spatial discretization or such dimension specified !";
1961 throw INTERP_KERNEL::Exception(oss.str().c_str());
1964 std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > notNullPflsPerGeoType2(notNullPflsPerGeoType.begin(),notNullPflsPerGeoType.end());
1965 std::vector< const DataArrayInt *> notNullPflsPerGeoType3(notNullPflsPerGeoType.begin(),notNullPflsPerGeoType.end());
1968 DataArrayInt *arr=mesh->checkTypeConsistencyAndContig(code,notNullPflsPerGeoType3);
1970 return finishField(type,glob,dads,locs,mesh,isPfl);
1973 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr2(arr);
1974 return finishField2(type,glob,dads,locs,geoTypes,mesh,arr,isPfl);
1980 throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getFieldOnMeshAtLevel : internal error #1 !");
1984 if(nb!=mesh->getNumberOfNodes())
1986 std::ostringstream oss; oss << "MEDFileFieldPerMesh::getFieldOnMeshAtLevel : There is a problem there is " << nb << " nodes in field whereas there is " << mesh->getNumberOfNodes();
1987 oss << " nodes in mesh !";
1988 throw INTERP_KERNEL::Exception(oss.str().c_str());
1990 return finishField(type,glob,dads,locs,mesh,isPfl);
1993 return finishFieldNode2(glob,dads,locs,mesh,notNullPflsPerGeoType3[0],isPfl);
1997 DataArrayDouble *MEDFileFieldPerMesh::getFieldOnMeshAtLevelWithPfl(TypeOfField type, const MEDCouplingMesh *mesh, DataArrayInt *&pfl, const MEDFileFieldGlobsReal *glob) const throw(INTERP_KERNEL::Exception)
1999 if(_field_pm_pt.empty())
2000 throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getFieldOnMeshAtLevel : no types field set !");
2002 std::vector<std::pair<int,int> > dads;
2003 std::vector<const DataArrayInt *> pfls;
2004 std::vector<DataArrayInt *> notNullPflsPerGeoType;
2005 std::vector<int> locs,code;
2006 std::vector<INTERP_KERNEL::NormalizedCellType> geoTypes;
2007 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2008 (*it)->getFieldAtLevel(mesh->getMeshDimension(),type,glob,dads,pfls,locs,geoTypes);
2010 SortArraysPerType(glob,type,geoTypes,dads,pfls,locs,code,notNullPflsPerGeoType);
2013 std::ostringstream oss; oss << "MEDFileFieldPerMesh::getFieldOnMeshAtLevelWithPfl : " << "The field \"" << getName() << "\" exists but not with such spatial discretization or such dimension specified !";
2014 throw INTERP_KERNEL::Exception(oss.str().c_str());
2016 std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > notNullPflsPerGeoType2(notNullPflsPerGeoType.begin(),notNullPflsPerGeoType.end());
2017 std::vector< const DataArrayInt *> notNullPflsPerGeoType3(notNullPflsPerGeoType.begin(),notNullPflsPerGeoType.end());
2020 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr=mesh->checkTypeConsistencyAndContig(code,notNullPflsPerGeoType3);
2021 return finishField4(dads,arr,mesh->getNumberOfCells(),pfl);
2026 throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getFieldOnMeshAtLevel : internal error #1 !");
2030 if(nb!=mesh->getNumberOfNodes())
2032 std::ostringstream oss; oss << "MEDFileFieldPerMesh::getFieldOnMeshAtLevel : There is a problem there is " << nb << " nodes in field whereas there is " << mesh->getNumberOfNodes();
2033 oss << " nodes in mesh !";
2034 throw INTERP_KERNEL::Exception(oss.str().c_str());
2037 return finishField4(dads,code[2]==-1?0:notNullPflsPerGeoType3[0],mesh->getNumberOfNodes(),pfl);
2043 DataArrayDouble *MEDFileFieldPerMesh::getUndergroundDataArrayExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const throw(INTERP_KERNEL::Exception)
2047 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2049 (*it)->getSizes(globalSz,nbOfEntries);
2051 entries.resize(nbOfEntries);
2053 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2055 (*it)->fillValues(nbOfEntries,entries);
2057 return _father->getUndergroundDataArray();
2060 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMesh::getLeafGivenTypeAndLocId(INTERP_KERNEL::NormalizedCellType typ, int locId) throw(INTERP_KERNEL::Exception)
2062 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2064 if((*it)->getGeoType()==typ)
2065 return (*it)->getLeafGivenLocId(locId);
2067 const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(typ);
2068 std::ostringstream oss; oss << "MEDFileFieldPerMesh::getLeafGivenTypeAndLocId : no such geometric type \"" << cm.getRepr() << "\" in this !" << std::endl;
2069 oss << "Possiblities are : ";
2070 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2072 const INTERP_KERNEL::CellModel& cm2=INTERP_KERNEL::CellModel::GetCellModel((*it)->getGeoType());
2073 oss << "\"" << cm2.getRepr() << "\", ";
2075 throw INTERP_KERNEL::Exception(oss.str().c_str());
2078 const MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMesh::getLeafGivenTypeAndLocId(INTERP_KERNEL::NormalizedCellType typ, int locId) const throw(INTERP_KERNEL::Exception)
2080 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2082 if((*it)->getGeoType()==typ)
2083 return (*it)->getLeafGivenLocId(locId);
2085 const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(typ);
2086 std::ostringstream oss; oss << "MEDFileFieldPerMesh::getLeafGivenTypeAndLocId : no such geometric type \"" << cm.getRepr() << "\" in this !" << std::endl;
2087 oss << "Possiblities are : ";
2088 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2090 const INTERP_KERNEL::CellModel& cm2=INTERP_KERNEL::CellModel::GetCellModel((*it)->getGeoType());
2091 oss << "\"" << cm2.getRepr() << "\", ";
2093 throw INTERP_KERNEL::Exception(oss.str().c_str());
2096 int MEDFileFieldPerMesh::addNewEntryIfNecessary(INTERP_KERNEL::NormalizedCellType type)
2099 int pos=std::distance(typmai2,std::find(typmai2,typmai2+MED_N_CELL_FIXED_GEO,type));
2100 std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it2=_field_pm_pt.begin();
2101 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++,i++)
2103 INTERP_KERNEL::NormalizedCellType curType=(*it)->getGeoType();
2108 int pos2=std::distance(typmai2,std::find(typmai2,typmai2+MED_N_CELL_FIXED_GEO,curType));
2113 int ret=std::distance(_field_pm_pt.begin(),it2);
2114 _field_pm_pt.insert(it2,MEDFileFieldPerMeshPerType::New(this,type));
2119 * 'dads' and 'locs' input parameters have the same number of elements
2120 * \param [in] mesh is \b NOT the global mesh, but the possibly reduced mesh. \a mesh parameter will be directly aggregated in the returned field
2122 MEDCouplingFieldDouble *MEDFileFieldPerMesh::finishField(TypeOfField type, const MEDFileFieldGlobsReal *glob,
2123 const std::vector< std::pair<int,int> >& dads, const std::vector<int>& locs,
2124 const MEDCouplingMesh *mesh, bool& isPfl) const throw(INTERP_KERNEL::Exception)
2127 MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=MEDCouplingFieldDouble::New(type,ONE_TIME);
2128 ret->setMesh(mesh); ret->setName(getName().c_str()); ret->setTime(getTime(),getIteration(),getOrder()); ret->setTimeUnit(getDtUnit().c_str());
2129 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> da=getArray()->selectByTupleRanges(dads);
2130 const std::vector<std::string>& infos=getInfo();
2131 da->setInfoOnComponents(infos);
2134 if(type==ON_GAUSS_PT)
2137 int nbOfArrs=dads.size();
2138 for(int i=0;i<nbOfArrs;i++)
2140 std::vector<std::pair<int,int> > dads2(1,dads[i]); const std::vector<int> locs2(1,locs[i]);
2141 const std::vector<INTERP_KERNEL::NormalizedCellType> geoTypes2(1,INTERP_KERNEL::NORM_ERROR);
2142 int nbOfElems=ComputeNbOfElems(glob,type,geoTypes2,dads2,locs2);
2143 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> di=DataArrayInt::New();
2144 di->alloc(nbOfElems,1);
2146 const MEDFileFieldLoc& fl=glob->getLocalizationFromId(locs[i]);
2147 ret->setGaussLocalizationOnCells(di->getConstPointer(),di->getConstPointer()+nbOfElems,fl.getRefCoords(),fl.getGaussCoords(),fl.getGaussWeights());
2156 * This method is an extension of MEDFileFieldPerMesh::finishField method. It deals with profiles. This method should be called when type is different from ON_NODES.
2157 * 'dads', 'locs' and 'geoTypes' input parameters have the same number of elements.
2158 * No check of this is performed. 'da' array contains an array in old2New style to be applyied to mesh to obtain the right support.
2159 * The order of cells in the returned field is those imposed by the profile.
2160 * \param [in] mesh is the global mesh.
2162 MEDCouplingFieldDouble *MEDFileFieldPerMesh::finishField2(TypeOfField type, const MEDFileFieldGlobsReal *glob,
2163 const std::vector<std::pair<int,int> >& dads, const std::vector<int>& locs,
2164 const std::vector<INTERP_KERNEL::NormalizedCellType>& geoTypes,
2165 const MEDCouplingMesh *mesh, const DataArrayInt *da, bool& isPfl) const throw(INTERP_KERNEL::Exception)
2167 if(da->isIdentity())
2169 int nbOfTuples=da->getNumberOfTuples();
2170 if(nbOfTuples==mesh->getNumberOfCells())
2171 return finishField(type,glob,dads,locs,mesh,isPfl);
2173 MEDCouplingAutoRefCountObjectPtr<MEDCouplingMesh> m2=mesh->buildPart(da->getConstPointer(),da->getConstPointer()+da->getNbOfElems());
2174 m2->setName(mesh->getName());
2175 MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=finishField(type,glob,dads,locs,m2,isPfl);
2181 * This method is the complement of MEDFileFieldPerMesh::finishField2 method except that this method works for node profiles.
2183 MEDCouplingFieldDouble *MEDFileFieldPerMesh::finishFieldNode2(const MEDFileFieldGlobsReal *glob,
2184 const std::vector<std::pair<int,int> >& dads, const std::vector<int>& locs,
2185 const MEDCouplingMesh *mesh, const DataArrayInt *da, bool& isPfl) const throw(INTERP_KERNEL::Exception)
2187 if(da->isIdentity())
2189 int nbOfTuples=da->getNumberOfTuples();
2190 if(nbOfTuples==mesh->getNumberOfNodes())//No problem for NORM_ERROR because it is in context of node
2191 return finishField(ON_NODES,glob,dads,locs,mesh,isPfl);
2193 // Treatment of particular case where nodal field on pfl is requested with a meshDimRelToMax=1.
2194 const MEDCouplingUMesh *meshu=dynamic_cast<const MEDCouplingUMesh *>(mesh);
2197 if(meshu->getNodalConnectivity()==0)
2199 MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=finishField(ON_CELLS,glob,dads,locs,mesh,isPfl);
2200 int nb=da->getNbOfElems();
2201 const int *ptr=da->getConstPointer();
2202 MEDCouplingUMesh *meshuc=const_cast<MEDCouplingUMesh *>(meshu);
2203 meshuc->allocateCells(nb);
2204 for(int i=0;i<nb;i++)
2205 meshuc->insertNextCell(INTERP_KERNEL::NORM_POINT1,1,ptr+i);
2206 meshuc->finishInsertingCells();
2207 ret->setMesh(meshuc);
2208 ret->checkCoherency();
2213 MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=finishField(ON_NODES,glob,dads,locs,mesh,isPfl);
2215 DataArrayInt *arr2=0;
2216 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> cellIds=mesh->getCellIdsFullyIncludedInNodeIds(da->getConstPointer(),da->getConstPointer()+da->getNbOfElems());
2217 MEDCouplingAutoRefCountObjectPtr<MEDCouplingMesh> mesh2=mesh->buildPartAndReduceNodes(cellIds->getConstPointer(),cellIds->getConstPointer()+cellIds->getNbOfElems(),arr2);
2218 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr3(arr2);
2219 int nnodes=mesh2->getNumberOfNodes();
2220 if(nnodes==da->getNbOfElems())
2222 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da3=da->transformWithIndArrR(arr2->begin(),arr2->end());
2223 ret->getArray()->renumberInPlace(da3->getConstPointer());
2224 mesh2->setName(mesh->getName());
2225 ret->setMesh(mesh2);
2230 std::ostringstream oss; oss << "MEDFileFieldPerMesh::finishFieldNode2 : The field on nodes lies on a node profile so that it is impossible to find a submesh having exactly the same nodes of that profile !!!";
2231 oss << "So it is impossible to return a well definied MEDCouplingFieldDouble instance on specified mesh on a specified meshDim !" << std::endl;
2232 oss << "To retrieve correctly such a field you have 3 possibilities :" << std::endl;
2233 oss << " - use an another meshDim compatible with the field on nodes (MED file does not have such information)" << std::endl;
2234 oss << " - use an another a meshDimRelToMax equal to 1 -> it will return a mesh with artificial cell POINT1 containing the profile !" << std::endl;
2235 oss << " - if definitely the node profile has no link with mesh connectivity use MEDFileField1TS::getFieldWithProfile or MEDFileFieldMultiTS::getFieldWithProfile methods instead !";
2236 throw INTERP_KERNEL::Exception(oss.str().c_str());
2242 * This method is the most light method of field retrieving.
2244 DataArrayDouble *MEDFileFieldPerMesh::finishField4(const std::vector<std::pair<int,int> >& dads, const DataArrayInt *pflIn, int nbOfElems, DataArrayInt *&pflOut) const throw(INTERP_KERNEL::Exception)
2248 pflOut=DataArrayInt::New();
2249 pflOut->alloc(nbOfElems,1);
2254 pflOut=const_cast<DataArrayInt*>(pflIn);
2257 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> safePfl(pflOut);
2258 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> da=getArray()->selectByTupleRanges(dads);
2259 const std::vector<std::string>& infos=getInfo();
2260 int nbOfComp=infos.size();
2261 for(int i=0;i<nbOfComp;i++)
2262 da->setInfoOnComponent(i,infos[i].c_str());
2267 MEDFileFieldPerMesh::MEDFileFieldPerMesh(med_idt fid, MEDFileField1TSWithoutSDA *fath, int meshCsit, int meshIteration, int meshOrder) throw(INTERP_KERNEL::Exception):_mesh_iteration(meshIteration),_mesh_order(meshOrder),
2268 _mesh_csit(meshCsit),_father(fath)
2270 INTERP_KERNEL::AutoPtr<char> meshName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
2271 INTERP_KERNEL::AutoPtr<char> pflName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
2272 INTERP_KERNEL::AutoPtr<char> locName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
2273 for(int i=0;i<MED_N_CELL_FIXED_GEO;i++)
2275 int nbProfile=MEDfield23nProfile(fid,getName().c_str(),getIteration(),getOrder(),MED_CELL,typmai[i],_mesh_csit,meshName,pflName,locName);
2278 _field_pm_pt.push_back(MEDFileFieldPerMeshPerType::NewOnRead(fid,this,ON_CELLS,typmai2[i]));
2279 _mesh_name=MEDLoaderBase::buildStringFromFortran(meshName,MED_NAME_SIZE+1);
2281 nbProfile=MEDfield23nProfile(fid,getName().c_str(),getIteration(),getOrder(),MED_NODE_ELEMENT,typmai[i],_mesh_csit,meshName,pflName,locName);
2284 _field_pm_pt.push_back(MEDFileFieldPerMeshPerType::NewOnRead(fid,this,ON_GAUSS_NE,typmai2[i]));
2285 _mesh_name=MEDLoaderBase::buildStringFromFortran(meshName,MED_NAME_SIZE+1);
2288 int nbProfile=MEDfield23nProfile(fid,getName().c_str(),getIteration(),getOrder(),MED_NODE,MED_NONE,_mesh_csit,meshName,pflName,locName);
2291 _field_pm_pt.push_back(MEDFileFieldPerMeshPerType::NewOnRead(fid,this,ON_NODES,INTERP_KERNEL::NORM_ERROR));
2292 _mesh_name=MEDLoaderBase::buildStringFromFortran(meshName,MED_NAME_SIZE+1);
2296 MEDFileFieldPerMesh::MEDFileFieldPerMesh(MEDFileField1TSWithoutSDA *fath, const MEDCouplingMesh *mesh):_father(fath)
2298 copyTinyInfoFrom(mesh);
2301 void MEDFileFieldGlobs::loadProfileInFile(med_idt fid, int id, const char *pflName) throw(INTERP_KERNEL::Exception)
2303 if(id>=(int)_pfls.size())
2305 _pfls[id]=DataArrayInt::New();
2306 int lgth=MEDprofileSizeByName(fid,pflName);
2307 _pfls[id]->setName(pflName);
2308 _pfls[id]->alloc(lgth,1);
2309 MEDprofileRd(fid,pflName,_pfls[id]->getPointer());
2310 _pfls[id]->applyLin(1,-1,0);//Converting into C format
2313 void MEDFileFieldGlobs::loadProfileInFile(med_idt fid, int i)
2315 INTERP_KERNEL::AutoPtr<char> pflName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
2317 MEDprofileInfo(fid,i+1,pflName,&sz);
2318 std::string pflCpp=MEDLoaderBase::buildStringFromFortran(pflName,MED_NAME_SIZE);
2319 if(i>=(int)_pfls.size())
2321 _pfls[i]=DataArrayInt::New();
2322 _pfls[i]->alloc(sz,1);
2323 _pfls[i]->setName(pflCpp.c_str());
2324 MEDprofileRd(fid,pflName,_pfls[i]->getPointer());
2325 _pfls[i]->applyLin(1,-1,0);//Converting into C format
2328 void MEDFileFieldGlobs::writeGlobals(med_idt fid, const MEDFileWritable& opt) const throw(INTERP_KERNEL::Exception)
2330 int nbOfPfls=_pfls.size();
2331 for(int i=0;i<nbOfPfls;i++)
2333 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> cpy=_pfls[i]->deepCpy();
2334 cpy->applyLin(1,1,0);
2335 INTERP_KERNEL::AutoPtr<char> pflName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
2336 MEDLoaderBase::safeStrCpy(_pfls[i]->getName().c_str(),MED_NAME_SIZE,pflName,opt.getTooLongStrPolicy());
2337 MEDprofileWr(fid,pflName,_pfls[i]->getNumberOfTuples(),cpy->getConstPointer());
2340 int nbOfLocs=_locs.size();
2341 for(int i=0;i<nbOfLocs;i++)
2342 _locs[i]->writeLL(fid);
2345 void MEDFileFieldGlobs::appendGlobs(const MEDFileFieldGlobs& other, double eps) throw(INTERP_KERNEL::Exception)
2347 std::vector<std::string> pfls=getPfls();
2348 for(std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::const_iterator it=other._pfls.begin();it!=other._pfls.end();it++)
2350 std::vector<std::string>::iterator it2=std::find(pfls.begin(),pfls.end(),(*it)->getName());
2353 _pfls.push_back(*it);
2357 int id=std::distance(pfls.begin(),it2);
2358 if(!(*it)->isEqual(*_pfls[id]))
2360 std::ostringstream oss; oss << "MEDFileFieldGlobs::appendGlobs : Profile \"" << (*it)->getName() << "\" already exists and is different from those expecting to be append !";
2361 throw INTERP_KERNEL::Exception(oss.str().c_str());
2365 std::vector<std::string> locs=getLocs();
2366 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> >::const_iterator it=_locs.begin();it!=_locs.end();it++)
2368 std::vector<std::string>::iterator it2=std::find(locs.begin(),locs.end(),(*it)->getName());
2371 _locs.push_back(*it);
2375 int id=std::distance(locs.begin(),it2);
2376 if(!(*it)->isEqual(*_locs[id],eps))
2378 std::ostringstream oss; oss << "MEDFileFieldGlobs::appendGlobs : Localization \"" << (*it)->getName() << "\" already exists and is different from those expecting to be append !";
2379 throw INTERP_KERNEL::Exception(oss.str().c_str());
2385 void MEDFileFieldGlobs::loadGlobals(med_idt fid, const MEDFileFieldGlobsReal& real) throw(INTERP_KERNEL::Exception)
2387 std::vector<std::string> profiles=real.getPflsReallyUsed();
2388 int sz=profiles.size();
2390 for(int i=0;i<sz;i++)
2391 loadProfileInFile(fid,i,profiles[i].c_str());
2393 std::vector<std::string> locs=real.getLocsReallyUsed();
2396 for(int i=0;i<sz;i++)
2397 _locs[i]=MEDFileFieldLoc::New(fid,locs[i].c_str());
2400 void MEDFileFieldGlobs::loadAllGlobals(med_idt fid) throw(INTERP_KERNEL::Exception)
2402 int nProfil=MEDnProfile(fid);
2403 for(int i=0;i<nProfil;i++)
2404 loadProfileInFile(fid,i);
2405 int sz=MEDnLocalization(fid);
2407 for(int i=0;i<sz;i++)
2409 _locs[i]=MEDFileFieldLoc::New(fid,i);
2413 MEDFileFieldGlobs *MEDFileFieldGlobs::New(const char *fname)
2415 return new MEDFileFieldGlobs(fname);
2418 MEDFileFieldGlobs *MEDFileFieldGlobs::New()
2420 return new MEDFileFieldGlobs;
2423 std::size_t MEDFileFieldGlobs::getHeapMemorySize() const
2425 std::size_t ret=_file_name.capacity()+_pfls.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr<DataArrayInt>)+_locs.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc>);
2426 for(std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::const_iterator it=_pfls.begin();it!=_pfls.end();it++)
2427 ret+=(*it)->getHeapMemorySize();
2428 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> >::const_iterator it=_locs.begin();it!=_locs.end();it++)
2429 ret+=(*it)->getHeapMemorySize();
2433 MEDFileFieldGlobs *MEDFileFieldGlobs::deepCpy() const throw(INTERP_KERNEL::Exception)
2435 MEDCouplingAutoRefCountObjectPtr<MEDFileFieldGlobs> ret=new MEDFileFieldGlobs(*this);
2437 for(std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::const_iterator it=_pfls.begin();it!=_pfls.end();it++,i++)
2439 if((const DataArrayInt *)*it)
2440 ret->_pfls[i]=(*it)->deepCpy();
2443 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> >::const_iterator it=_locs.begin();it!=_locs.end();it++,i++)
2445 if((const MEDFileFieldLoc*)*it)
2446 ret->_locs[i]=(*it)->deepCpy();
2451 MEDFileFieldGlobs::MEDFileFieldGlobs(const char *fname):_file_name(fname)
2455 MEDFileFieldGlobs::MEDFileFieldGlobs()
2459 MEDFileFieldGlobs::~MEDFileFieldGlobs()
2463 void MEDFileFieldGlobs::simpleRepr(std::ostream& oss) const
2465 oss << "Profiles :\n";
2466 std::size_t n=_pfls.size();
2467 for(std::size_t i=0;i<n;i++)
2469 oss << " - #" << i << " ";
2470 const DataArrayInt *pfl=_pfls[i];
2472 oss << "\"" << pfl->getName() << "\"\n";
2477 oss << "Localizations :\n";
2478 for(std::size_t i=0;i<n;i++)
2480 oss << " - #" << i << " ";
2481 const MEDFileFieldLoc *loc=_locs[i];
2483 loc->simpleRepr(oss);
2489 void MEDFileFieldGlobs::setFileName(const char *fileName)
2491 _file_name=fileName;
2494 void MEDFileFieldGlobs::changePflsNamesInStruct(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
2496 for(std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::iterator it=_pfls.begin();it!=_pfls.end();it++)
2498 DataArrayInt *elt(*it);
2501 std::string name(elt->getName());
2502 for(std::vector< std::pair<std::vector<std::string>, std::string > >::const_iterator it2=mapOfModif.begin();it2!=mapOfModif.end();it2++)
2504 if(std::find((*it2).first.begin(),(*it2).first.end(),name)!=(*it2).first.end())
2506 elt->setName((*it2).second.c_str());
2514 void MEDFileFieldGlobs::changeLocsNamesInStruct(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
2516 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> >::iterator it=_locs.begin();it!=_locs.end();it++)
2518 MEDFileFieldLoc *elt(*it);
2521 std::string name(elt->getName());
2522 for(std::vector< std::pair<std::vector<std::string>, std::string > >::const_iterator it2=mapOfModif.begin();it2!=mapOfModif.end();it2++)
2524 if(std::find((*it2).first.begin(),(*it2).first.end(),name)!=(*it2).first.end())
2526 elt->setName((*it2).second.c_str());
2534 int MEDFileFieldGlobs::getNbOfGaussPtPerCell(int locId) const throw(INTERP_KERNEL::Exception)
2536 if(locId<0 || locId>=(int)_locs.size())
2537 throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::getNbOfGaussPtPerCell : Invalid localization id !");
2538 return _locs[locId]->getNbOfGaussPtPerCell();
2541 const MEDFileFieldLoc& MEDFileFieldGlobs::getLocalization(const char *locName) const throw(INTERP_KERNEL::Exception)
2543 return getLocalizationFromId(getLocalizationId(locName));
2546 const MEDFileFieldLoc& MEDFileFieldGlobs::getLocalizationFromId(int locId) const throw(INTERP_KERNEL::Exception)
2548 if(locId<0 || locId>=(int)_locs.size())
2549 throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::getLocalizationFromId : Invalid localization id !");
2550 return *_locs[locId];
2553 namespace ParaMEDMEMImpl
2558 LocFinder(const char *loc):_loc(loc) { }
2559 bool operator() (const MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc>& loc) { return loc->isName(_loc); }
2567 PflFinder(const std::string& pfl):_pfl(pfl) { }
2568 bool operator() (const MEDCouplingAutoRefCountObjectPtr<DataArrayInt>& pfl) { return _pfl==pfl->getName(); }
2570 const std::string& _pfl;
2574 int MEDFileFieldGlobs::getLocalizationId(const char *loc) const throw(INTERP_KERNEL::Exception)
2576 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> >::const_iterator it=std::find_if(_locs.begin(),_locs.end(),ParaMEDMEMImpl::LocFinder(loc));
2579 std::ostringstream oss; oss << "MEDFileFieldGlobs::getLocalisationId : no such localisation name : \"" << loc << "\" Possible localizations are : ";
2580 for(it=_locs.begin();it!=_locs.end();it++)
2581 oss << "\"" << (*it)->getName() << "\", ";
2582 throw INTERP_KERNEL::Exception(oss.str().c_str());
2584 return std::distance(_locs.begin(),it);
2587 const DataArrayInt *MEDFileFieldGlobs::getProfile(const char *pflName) const throw(INTERP_KERNEL::Exception)
2589 std::string pflNameCpp(pflName);
2590 std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::const_iterator it=std::find_if(_pfls.begin(),_pfls.end(),ParaMEDMEMImpl::PflFinder(pflNameCpp));
2593 std::ostringstream oss; oss << "MEDFileFieldGlobs::getProfile: no such profile name : \"" << pflNameCpp << "\" Possible profiles are : ";
2594 for(it=_pfls.begin();it!=_pfls.end();it++)
2595 oss << "\"" << (*it)->getName() << "\", ";
2596 throw INTERP_KERNEL::Exception(oss.str().c_str());
2601 const DataArrayInt *MEDFileFieldGlobs::getProfileFromId(int pflId) const throw(INTERP_KERNEL::Exception)
2603 if(pflId<0 || pflId>=(int)_pfls.size())
2604 throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::getProfileFromId : Invalid profile id !");
2605 return _pfls[pflId];
2608 MEDFileFieldLoc& MEDFileFieldGlobs::getLocalizationFromId(int locId) throw(INTERP_KERNEL::Exception)
2610 if(locId<0 || locId>=(int)_locs.size())
2611 throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::getLocalizationFromId : Invalid localization id !");
2612 return *_locs[locId];
2615 MEDFileFieldLoc& MEDFileFieldGlobs::getLocalization(const char *locName) throw(INTERP_KERNEL::Exception)
2617 return getLocalizationFromId(getLocalizationId(locName));
2620 DataArrayInt *MEDFileFieldGlobs::getProfile(const char *pflName) throw(INTERP_KERNEL::Exception)
2622 std::string pflNameCpp(pflName);
2623 std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::iterator it=std::find_if(_pfls.begin(),_pfls.end(),ParaMEDMEMImpl::PflFinder(pflNameCpp));
2626 std::ostringstream oss; oss << "MEDFileFieldGlobs::getProfile: no such profile name : \"" << pflNameCpp << "\" Possible profiles are : ";
2627 for(it=_pfls.begin();it!=_pfls.end();it++)
2628 oss << "\"" << (*it)->getName() << "\", ";
2629 throw INTERP_KERNEL::Exception(oss.str().c_str());
2634 DataArrayInt *MEDFileFieldGlobs::getProfileFromId(int pflId) throw(INTERP_KERNEL::Exception)
2636 if(pflId<0 || pflId>=(int)_pfls.size())
2637 throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::getProfileFromId : Invalid profile id !");
2638 return _pfls[pflId];
2641 void MEDFileFieldGlobs::killProfileIds(const std::vector<int>& pflIds) throw(INTERP_KERNEL::Exception)
2643 std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > newPfls;
2645 for(std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::const_iterator it=_pfls.begin();it!=_pfls.end();it++,i++)
2647 if(std::find(pflIds.begin(),pflIds.end(),i)==pflIds.end())
2648 newPfls.push_back(*it);
2653 void MEDFileFieldGlobs::killLocalizationIds(const std::vector<int>& locIds) throw(INTERP_KERNEL::Exception)
2655 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> > newLocs;
2657 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> >::const_iterator it=_locs.begin();it!=_locs.end();it++,i++)
2659 if(std::find(locIds.begin(),locIds.end(),i)==locIds.end())
2660 newLocs.push_back(*it);
2665 std::vector<std::string> MEDFileFieldGlobs::getPfls() const
2667 int sz=_pfls.size();
2668 std::vector<std::string> ret(sz);
2669 for(int i=0;i<sz;i++)
2670 ret[i]=_pfls[i]->getName();
2674 std::vector<std::string> MEDFileFieldGlobs::getLocs() const
2676 int sz=_locs.size();
2677 std::vector<std::string> ret(sz);
2678 for(int i=0;i<sz;i++)
2679 ret[i]=_locs[i]->getName();
2683 bool MEDFileFieldGlobs::existsPfl(const char *pflName) const
2685 std::vector<std::string> v=getPfls();
2686 std::string s(pflName);
2687 return std::find(v.begin(),v.end(),s)!=v.end();
2690 bool MEDFileFieldGlobs::existsLoc(const char *locName) const
2692 std::vector<std::string> v=getLocs();
2693 std::string s(locName);
2694 return std::find(v.begin(),v.end(),s)!=v.end();
2697 std::vector< std::vector<int> > MEDFileFieldGlobs::whichAreEqualProfiles() const
2699 std::map<int,std::vector<int> > m;
2701 for(std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::const_iterator it=_pfls.begin();it!=_pfls.end();it++,i++)
2703 const DataArrayInt *tmp=(*it);
2706 m[tmp->getHashCode()].push_back(i);
2709 std::vector< std::vector<int> > ret;
2710 for(std::map<int,std::vector<int> >::const_iterator it2=m.begin();it2!=m.end();it2++)
2712 if((*it2).second.size()>1)
2714 std::vector<int> ret0;
2715 bool equalityOrNot=false;
2716 for(std::vector<int>::const_iterator it3=(*it2).second.begin();it3!=(*it2).second.end();it3++)
2718 std::vector<int>::const_iterator it4=it3; it4++;
2719 for(;it4!=(*it2).second.end();it4++)
2721 if(_pfls[*it3]->isEqualWithoutConsideringStr(*_pfls[*it4]))
2724 ret0.push_back(*it3);
2725 ret0.push_back(*it4);
2731 ret.push_back(ret0);
2737 std::vector< std::vector<int> > MEDFileFieldGlobs::whichAreEqualLocs(double eps) const
2739 throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::whichAreEqualLocs : no implemented yet ! Sorry !");
2742 void MEDFileFieldGlobs::appendProfile(DataArrayInt *pfl) throw(INTERP_KERNEL::Exception)
2744 std::string name(pfl->getName());
2746 throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::appendProfile : unsupported profiles with no name !");
2747 for(std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::const_iterator it=_pfls.begin();it!=_pfls.end();it++)
2748 if(name==(*it)->getName())
2750 if(!pfl->isEqual(*(*it)))
2752 std::ostringstream oss; oss << "MEDFileFieldGlobs::appendProfile : profile \"" << name << "\" already exists and is different from existing !";
2753 throw INTERP_KERNEL::Exception(oss.str().c_str());
2757 _pfls.push_back(pfl);
2760 void MEDFileFieldGlobs::appendLoc(const char *locName, INTERP_KERNEL::NormalizedCellType geoType, const std::vector<double>& refCoo, const std::vector<double>& gsCoo, const std::vector<double>& w) throw(INTERP_KERNEL::Exception)
2762 std::string name(locName);
2764 throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::appendLoc : unsupported localizations with no name !");
2765 MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> obj=MEDFileFieldLoc::New(locName,geoType,refCoo,gsCoo,w);
2766 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> >::const_iterator it=_locs.begin();it!=_locs.end();it++)
2767 if((*it)->isName(locName))
2769 if(!(*it)->isEqual(*obj,1e-12))
2771 std::ostringstream oss; oss << "MEDFileFieldGlobs::appendLoc : localization \"" << name << "\" already exists and is different from existing !";
2772 throw INTERP_KERNEL::Exception(oss.str().c_str());
2775 _locs.push_back(obj);
2778 std::string MEDFileFieldGlobs::createNewNameOfPfl() const throw(INTERP_KERNEL::Exception)
2780 std::vector<std::string> names=getPfls();
2781 return CreateNewNameNotIn("NewPfl_",names);
2784 std::string MEDFileFieldGlobs::createNewNameOfLoc() const throw(INTERP_KERNEL::Exception)
2786 std::vector<std::string> names=getLocs();
2787 return CreateNewNameNotIn("NewLoc_",names);
2790 std::string MEDFileFieldGlobs::CreateNewNameNotIn(const char *prefix, const std::vector<std::string>& namesToAvoid) throw(INTERP_KERNEL::Exception)
2792 for(std::size_t sz=0;sz<100000;sz++)
2794 std::ostringstream tryName;
2795 tryName << prefix << sz;
2796 if(std::find(namesToAvoid.begin(),namesToAvoid.end(),tryName.str())==namesToAvoid.end())
2797 return tryName.str();
2799 throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::CreateNewNameNotIn : impossible to create an additional profile limit of 100000 profiles reached !");
2802 MEDFileFieldGlobsReal::MEDFileFieldGlobsReal(const char *fname):_globals(MEDFileFieldGlobs::New(fname))
2806 MEDFileFieldGlobsReal::MEDFileFieldGlobsReal():_globals(MEDFileFieldGlobs::New())
2810 std::size_t MEDFileFieldGlobsReal::getHeapMemorySize() const
2813 if((const MEDFileFieldGlobs *)_globals)
2814 ret+=_globals->getHeapMemorySize();
2818 void MEDFileFieldGlobsReal::simpleRepr(std::ostream& oss) const
2820 oss << "Globals information on fields :" << "\n*******************************\n\n";
2821 const MEDFileFieldGlobs *glob=_globals;
2823 glob->simpleRepr(oss);
2825 oss << "NO GLOBAL INFORMATION !\n";
2828 MEDFileFieldGlobsReal::~MEDFileFieldGlobsReal()
2832 void MEDFileFieldGlobsReal::shallowCpyGlobs(const MEDFileFieldGlobsReal& other)
2834 _globals=other._globals;
2837 void MEDFileFieldGlobsReal::deepCpyGlobs(const MEDFileFieldGlobsReal& other)
2839 _globals=other._globals;
2840 if((const MEDFileFieldGlobs *)_globals)
2841 _globals=other._globals->deepCpy();
2844 void MEDFileFieldGlobsReal::appendGlobs(const MEDFileFieldGlobsReal& other, double eps) throw(INTERP_KERNEL::Exception)
2846 _globals->appendGlobs(*other._globals,eps);
2849 void MEDFileFieldGlobsReal::loadProfileInFile(med_idt fid, int id, const char *pflName) throw(INTERP_KERNEL::Exception)
2851 _globals->loadProfileInFile(fid,id,pflName);
2854 void MEDFileFieldGlobsReal::loadProfileInFile(med_idt fid, int id)
2856 _globals->loadProfileInFile(fid,id);
2859 void MEDFileFieldGlobsReal::loadGlobals(med_idt fid) throw(INTERP_KERNEL::Exception)
2861 _globals->loadGlobals(fid,*this);
2864 void MEDFileFieldGlobsReal::loadAllGlobals(med_idt fid) throw(INTERP_KERNEL::Exception)
2866 _globals->loadAllGlobals(fid);
2869 void MEDFileFieldGlobsReal::writeGlobals(med_idt fid, const MEDFileWritable& opt) const throw(INTERP_KERNEL::Exception)
2871 _globals->writeGlobals(fid,opt);
2874 std::vector<std::string> MEDFileFieldGlobsReal::getPfls() const
2876 return _globals->getPfls();
2879 std::vector<std::string> MEDFileFieldGlobsReal::getLocs() const
2881 return _globals->getLocs();
2884 bool MEDFileFieldGlobsReal::existsPfl(const char *pflName) const
2886 return _globals->existsPfl(pflName);
2889 bool MEDFileFieldGlobsReal::existsLoc(const char *locName) const
2891 return _globals->existsLoc(locName);
2894 std::string MEDFileFieldGlobsReal::createNewNameOfPfl() const throw(INTERP_KERNEL::Exception)
2896 return _globals->createNewNameOfPfl();
2899 std::string MEDFileFieldGlobsReal::createNewNameOfLoc() const throw(INTERP_KERNEL::Exception)
2901 return _globals->createNewNameOfLoc();
2904 void MEDFileFieldGlobsReal::setFileName(const char *fileName)
2906 _globals->setFileName(fileName);
2909 std::vector< std::vector<int> > MEDFileFieldGlobsReal::whichAreEqualProfiles() const
2911 return _globals->whichAreEqualProfiles();
2914 std::vector< std::vector<int> > MEDFileFieldGlobsReal::whichAreEqualLocs(double eps) const
2916 return _globals->whichAreEqualLocs(eps);
2919 void MEDFileFieldGlobsReal::changePflsNamesInStruct(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
2921 _globals->changePflsNamesInStruct(mapOfModif);
2924 void MEDFileFieldGlobsReal::changeLocsNamesInStruct(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
2926 _globals->changeLocsNamesInStruct(mapOfModif);
2930 * This method is a generalization of MEDFileFieldGlobsReal::changePflName.
2931 * This method contrary to abstract method MEDFileFieldGlobsReal::changePflsRefsNamesGen updates in addition of MEDFileFieldGlobsReal::changePflsRefsNamesGen,
2932 * the profiles themselves and not only leaves of field.
2934 void MEDFileFieldGlobsReal::changePflsNames(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
2936 changePflsRefsNamesGen(mapOfModif);
2937 changePflsNamesInStruct(mapOfModif);
2941 * This method is a generalization of MEDFileFieldGlobsReal::changePflName.
2942 * This method contrary to abstract method MEDFileFieldGlobsReal::changeLocsRefsNamesGen updates in addition of MEDFileFieldGlobsReal::changeLocsRefsNamesGen,
2943 * the localizations themselves and not only leaves of field.
2945 void MEDFileFieldGlobsReal::changeLocsNames(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
2947 changeLocsRefsNamesGen(mapOfModif);
2948 changeLocsNamesInStruct(mapOfModif);
2952 * This method is a more friendly API but less general method than MEDFileFieldGlobsReal::changePflsNames.
2954 void MEDFileFieldGlobsReal::changePflName(const char *oldName, const char *newName) throw(INTERP_KERNEL::Exception)
2956 std::vector< std::pair<std::vector<std::string>, std::string > > mapOfModif(1);
2957 std::pair<std::vector<std::string>, std::string > p(std::vector<std::string>(1,std::string(oldName)),std::string(newName));
2959 changePflsNames(mapOfModif);
2963 * This method is a more friendly API but less general method than MEDFileFieldGlobsReal::changeLocsNames.
2965 void MEDFileFieldGlobsReal::changeLocName(const char *oldName, const char *newName) throw(INTERP_KERNEL::Exception)
2967 std::vector< std::pair<std::vector<std::string>, std::string > > mapOfModif(1);
2968 std::pair<std::vector<std::string>, std::string > p(std::vector<std::string>(1,std::string(oldName)),std::string(newName));
2970 changeLocsNames(mapOfModif);
2973 std::vector< std::pair<std::vector<std::string>, std::string > > MEDFileFieldGlobsReal::zipPflsNames() throw(INTERP_KERNEL::Exception)
2975 std::vector< std::vector<int> > pseudoRet=whichAreEqualProfiles();
2976 std::vector< std::pair<std::vector<std::string>, std::string > > ret(pseudoRet.size());
2978 for(std::vector< std::vector<int> >::const_iterator it=pseudoRet.begin();it!=pseudoRet.end();it++,i++)
2980 std::vector< std::string > tmp((*it).size());
2982 for(std::vector<int>::const_iterator it2=(*it).begin();it2!=(*it).end();it2++,j++)
2983 tmp[j]=std::string(getProfileFromId(*it2)->getName());
2984 std::pair<std::vector<std::string>, std::string > p(tmp,tmp.front());
2986 std::vector<int> tmp2((*it).begin()+1,(*it).end());
2987 killProfileIds(tmp2);
2989 changePflsRefsNamesGen(ret);
2993 std::vector< std::pair<std::vector<std::string>, std::string > > MEDFileFieldGlobsReal::zipLocsNames(double eps) throw(INTERP_KERNEL::Exception)
2995 std::vector< std::vector<int> > pseudoRet=whichAreEqualLocs(eps);
2996 std::vector< std::pair<std::vector<std::string>, std::string > > ret(pseudoRet.size());
2998 for(std::vector< std::vector<int> >::const_iterator it=pseudoRet.begin();it!=pseudoRet.end();it++,i++)
3000 std::vector< std::string > tmp((*it).size());
3002 for(std::vector<int>::const_iterator it2=(*it).begin();it2!=(*it).end();it2++,j++)
3003 tmp[j]=std::string(getLocalizationFromId(*it2).getName());
3004 std::pair<std::vector<std::string>, std::string > p(tmp,tmp.front());
3006 std::vector<int> tmp2((*it).begin()+1,(*it).end());
3007 killLocalizationIds(tmp2);
3009 changeLocsRefsNamesGen(ret);
3013 int MEDFileFieldGlobsReal::getNbOfGaussPtPerCell(int locId) const throw(INTERP_KERNEL::Exception)
3015 return _globals->getNbOfGaussPtPerCell(locId);
3018 int MEDFileFieldGlobsReal::getLocalizationId(const char *loc) const throw(INTERP_KERNEL::Exception)
3020 return _globals->getLocalizationId(loc);
3023 const char *MEDFileFieldGlobsReal::getFileName() const
3025 return _globals->getFileName();
3028 std::string MEDFileFieldGlobsReal::getFileName2() const
3030 return _globals->getFileName2();
3033 const MEDFileFieldLoc& MEDFileFieldGlobsReal::getLocalization(const char *locName) const throw(INTERP_KERNEL::Exception)
3035 return _globals->getLocalization(locName);
3038 const MEDFileFieldLoc& MEDFileFieldGlobsReal::getLocalizationFromId(int locId) const throw(INTERP_KERNEL::Exception)
3040 return _globals->getLocalizationFromId(locId);
3043 const DataArrayInt *MEDFileFieldGlobsReal::getProfile(const char *pflName) const throw(INTERP_KERNEL::Exception)
3045 return _globals->getProfile(pflName);
3048 const DataArrayInt *MEDFileFieldGlobsReal::getProfileFromId(int pflId) const throw(INTERP_KERNEL::Exception)
3050 return _globals->getProfileFromId(pflId);
3053 MEDFileFieldLoc& MEDFileFieldGlobsReal::getLocalizationFromId(int locId) throw(INTERP_KERNEL::Exception)
3055 return _globals->getLocalizationFromId(locId);
3058 MEDFileFieldLoc& MEDFileFieldGlobsReal::getLocalization(const char *locName) throw(INTERP_KERNEL::Exception)
3060 return _globals->getLocalization(locName);
3063 DataArrayInt *MEDFileFieldGlobsReal::getProfile(const char *pflName) throw(INTERP_KERNEL::Exception)
3065 return _globals->getProfile(pflName);
3068 DataArrayInt *MEDFileFieldGlobsReal::getProfileFromId(int pflId) throw(INTERP_KERNEL::Exception)
3070 return _globals->getProfileFromId(pflId);
3073 void MEDFileFieldGlobsReal::killProfileIds(const std::vector<int>& pflIds) throw(INTERP_KERNEL::Exception)
3075 _globals->killProfileIds(pflIds);
3078 void MEDFileFieldGlobsReal::killLocalizationIds(const std::vector<int>& locIds) throw(INTERP_KERNEL::Exception)
3080 _globals->killLocalizationIds(locIds);
3083 void MEDFileFieldGlobsReal::appendProfile(DataArrayInt *pfl) throw(INTERP_KERNEL::Exception)
3085 _globals->appendProfile(pfl);
3088 void MEDFileFieldGlobsReal::appendLoc(const char *locName, INTERP_KERNEL::NormalizedCellType geoType, const std::vector<double>& refCoo, const std::vector<double>& gsCoo, const std::vector<double>& w) throw(INTERP_KERNEL::Exception)
3090 _globals->appendLoc(locName,geoType,refCoo,gsCoo,w);
3094 * This method returns the max dimension of 'this'.
3095 * This method returns -2 if 'this' is empty, -1 if only nodes are defined.
3097 int MEDFileField1TSWithoutSDA::getDimension() const
3100 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3101 (*it)->getDimension(ret);
3105 void MEDFileField1TSWithoutSDA::CheckMeshDimRel(int meshDimRelToMax) throw(INTERP_KERNEL::Exception)
3107 if(meshDimRelToMax>0)
3108 throw INTERP_KERNEL::Exception("CheckMeshDimRel : This is a meshDimRel not a meshDimRelExt ! So value should be <=0 !");
3111 std::vector<int> MEDFileField1TSWithoutSDA::CheckSBTMesh(const MEDCouplingMesh *mesh) throw(INTERP_KERNEL::Exception)
3114 std::set<INTERP_KERNEL::NormalizedCellType> geoTypes=mesh->getAllGeoTypes();
3115 int nbOfTypes=geoTypes.size();
3116 std::vector<int> code(3*nbOfTypes);
3117 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr1=DataArrayInt::New();
3118 arr1->alloc(nbOfTypes,1);
3119 int *arrPtr=arr1->getPointer();
3120 std::set<INTERP_KERNEL::NormalizedCellType>::const_iterator it=geoTypes.begin();
3121 for(int i=0;i<nbOfTypes;i++,it++)
3122 arrPtr[i]=std::distance(typmai2,std::find(typmai2,typmai2+MED_N_CELL_FIXED_GEO,*it));
3123 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr2=arr1->checkAndPreparePermutation();
3124 const int *arrPtr2=arr2->getConstPointer();
3126 for(it=geoTypes.begin();it!=geoTypes.end();it++,i++)
3129 int nbCells=mesh->getNumberOfCellsWithType(*it);
3130 code[3*pos]=(int)(*it);
3131 code[3*pos+1]=nbCells;
3132 code[3*pos+2]=-1;//no profiles
3134 std::vector<const DataArrayInt *> idsPerType;//no profiles
3135 DataArrayInt *da=mesh->checkTypeConsistencyAndContig(code,idsPerType);
3139 throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::CheckSBTMesh : underlying mesh is not sorted by type as MED file expects !");
3144 MEDFileField1TSWithoutSDA *MEDFileField1TSWithoutSDA::New(const char *fieldName, int csit, int fieldtype, int iteration, int order, const std::vector<std::string>& infos)
3146 return new MEDFileField1TSWithoutSDA(fieldName,csit,fieldtype,iteration,order,infos);
3150 * This method copyies tiny info but also preallocated the DataArrayDouble instance in this->_arr.
3151 * This not allocated it allocates to the size of 'field' array. If already allocated it grows the array to
3152 * the previous size + the size of the array of the input 'field'.
3153 * This method returns the position (in tuple id) where to start to feed 'this->_arr'
3155 int MEDFileField1TSWithoutSDA::copyTinyInfoFrom(const MEDCouplingFieldDouble *field) throw(INTERP_KERNEL::Exception)
3157 std::string name(field->getName());
3158 getOrCreateAndGetArray()->setName(name.c_str());
3160 throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::copyTinyInfoFrom : unsupported fields with no name in MED file !");
3161 const DataArrayDouble *arr=field->getArray();
3163 throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::copyTinyInfoFrom : no array set !");
3164 _dt=field->getTime(_iteration,_order);
3165 int nbOfComponents=arr->getNumberOfComponents();
3166 getOrCreateAndGetArray()->setInfoAndChangeNbOfCompo(arr->getInfoOnComponents());
3167 if(!getOrCreateAndGetArray()->isAllocated())
3169 _arr->alloc(arr->getNumberOfTuples(),arr->getNumberOfComponents());
3174 int oldNbOfTuples=getOrCreateAndGetArray()->getNumberOfTuples();
3175 int newNbOfTuples=oldNbOfTuples+arr->getNumberOfTuples();
3176 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> tmp=DataArrayDouble::New();
3177 tmp->alloc(newNbOfTuples,nbOfComponents);
3178 tmp->copyStringInfoFrom(*_arr);
3179 std::copy(_arr->begin(),_arr->end(),tmp->getPointer());
3181 return oldNbOfTuples;
3185 std::string MEDFileField1TSWithoutSDA::getName() const
3187 const DataArrayDouble *arr=getOrCreateAndGetArray();
3188 return arr->getName();
3191 void MEDFileField1TSWithoutSDA::setName(const char *name)
3193 DataArrayDouble *arr=getOrCreateAndGetArray();
3197 void MEDFileField1TSWithoutSDA::simpleRepr(int bkOffset, std::ostream& oss, int f1tsId) const
3199 std::string startOfLine(bkOffset,' ');
3200 oss << startOfLine << "Field on One time Step ";
3202 oss << "(" << f1tsId << ") ";
3203 oss << "on iteration=" << _iteration << " order=" << _order << "." << std::endl;
3204 oss << startOfLine << "Time attached is : " << _dt << " [" << _dt_unit << "]." << std::endl;
3205 const DataArrayDouble *arr=_arr;
3208 const std::vector<std::string> &comps=arr->getInfoOnComponents();
3211 oss << startOfLine << "Field Name : \"" << arr->getName() << "\"." << std::endl;
3212 oss << startOfLine << "Field has " << comps.size() << " components with the following infos :" << std::endl;
3213 for(std::vector<std::string>::const_iterator it=comps.begin();it!=comps.end();it++)
3214 oss << startOfLine << " - \"" << (*it) << "\"" << std::endl;
3216 if(arr->isAllocated())
3218 oss << startOfLine << "Whole field contains " << arr->getNumberOfTuples() << " tuples." << std::endl;
3221 oss << startOfLine << "The array of the current field has not allocated yet !" << std::endl;
3225 oss << startOfLine << "Field infos are empty ! Not defined yet !" << std::endl;
3227 oss << startOfLine << "----------------------" << std::endl;
3228 if(!_field_per_mesh.empty())
3231 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it2=_field_per_mesh.begin();it2!=_field_per_mesh.end();it2++,i++)
3233 const MEDFileFieldPerMesh *cur=(*it2);
3235 cur->simpleRepr(bkOffset,oss,i);
3237 oss << startOfLine << "Field per mesh #" << i << " is not defined !" << std::endl;
3242 oss << startOfLine << "Field is not defined on any meshes !" << std::endl;
3244 oss << startOfLine << "----------------------" << std::endl;
3247 std::string MEDFileField1TSWithoutSDA::getMeshName() const throw(INTERP_KERNEL::Exception)
3249 if(_field_per_mesh.empty())
3250 throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::getMeshName : No field set !");
3251 return _field_per_mesh[0]->getMeshName();
3254 void MEDFileField1TSWithoutSDA::setMeshName(const char *newMeshName) throw(INTERP_KERNEL::Exception)
3256 std::string oldName(getMeshName());
3257 std::vector< std::pair<std::string,std::string> > v(1);
3258 v[0].first=oldName; v[0].second=newMeshName;
3262 bool MEDFileField1TSWithoutSDA::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab) throw(INTERP_KERNEL::Exception)
3265 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3267 MEDFileFieldPerMesh *cur(*it);
3269 ret=cur->changeMeshNames(modifTab) || ret;
3274 bool MEDFileField1TSWithoutSDA::renumberEntitiesLyingOnMesh(const char *meshName, const std::vector<int>& oldCode, const std::vector<int>& newCode, const DataArrayInt *renumO2N,
3275 MEDFileFieldGlobsReal& glob) throw(INTERP_KERNEL::Exception)
3278 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3280 MEDFileFieldPerMesh *fpm(*it);
3282 ret=fpm->renumberEntitiesLyingOnMesh(meshName,oldCode,newCode,renumO2N,glob) || ret;
3287 int MEDFileField1TSWithoutSDA::getMeshIteration() const throw(INTERP_KERNEL::Exception)
3289 if(_field_per_mesh.empty())
3290 throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::getMeshIteration : No field set !");
3291 return _field_per_mesh[0]->getMeshIteration();
3294 int MEDFileField1TSWithoutSDA::getMeshOrder() const throw(INTERP_KERNEL::Exception)
3296 if(_field_per_mesh.empty())
3297 throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::getMeshOrder : No field set !");
3298 return _field_per_mesh[0]->getMeshOrder();
3301 int MEDFileField1TSWithoutSDA::getNumberOfComponents() const
3303 return getOrCreateAndGetArray()->getNumberOfComponents();
3306 bool MEDFileField1TSWithoutSDA::isDealingTS(int iteration, int order) const
3308 return iteration==_iteration && order==_order;
3311 std::pair<int,int> MEDFileField1TSWithoutSDA::getDtIt() const
3313 std::pair<int,int> p;
3318 void MEDFileField1TSWithoutSDA::fillIteration(std::pair<int,int>& p) const
3324 void MEDFileField1TSWithoutSDA::fillTypesOfFieldAvailable(std::vector<TypeOfField>& types) const throw(INTERP_KERNEL::Exception)
3326 std::set<TypeOfField> types2;
3327 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3329 (*it)->fillTypesOfFieldAvailable(types2);
3331 std::back_insert_iterator< std::vector<TypeOfField> > bi(types);
3332 std::copy(types2.begin(),types2.end(),bi);
3335 const std::vector<std::string>& MEDFileField1TSWithoutSDA::getInfo() const
3337 const DataArrayDouble *arr=getOrCreateAndGetArray();
3338 return arr->getInfoOnComponents();
3341 std::vector<std::string>& MEDFileField1TSWithoutSDA::getInfo()
3343 DataArrayDouble *arr=getOrCreateAndGetArray();
3344 return arr->getInfoOnComponents();
3348 * This method has one input 'mname'. It can be null if the user is the general case where there is only one meshName lying on 'this'
3349 * This method returns two things.
3350 * - The absolute dimension of 'this' in first parameter.
3351 * - The available ext levels relative to the absolute dimension returned in first parameter. These relative levels are relative
3352 * to the first output parameter. The values in 'levs' will be returned in decreasing order.
3354 * This method is designed for MEDFileField1TS instances that have a discritization ON_CELLS, ON_GAUSS_NE and ON_GAUSS.
3355 * Only these 3 discretizations will be taken into account here.
3357 * If 'this' is empty this method will throw an INTERP_KERNEL::Exception.
3358 * If there is \b only node fields defined in 'this' -1 is returned and 'levs' output parameter will be empty. In this
3359 * case the caller has to know the underlying mesh it refers to. By defaut it is the level 0 of the corresponding mesh.
3361 * This method is usefull to make the link between meshDimension of the underlying mesh in 'this' and the levels on 'this'.
3362 * It is possible (even if it is not common) that the highest level in 'this' were not equal to the meshDimension of the underlying mesh in 'this'.
3364 * Let's consider the typical following case :
3365 * - a mesh 'm1' has a meshDimension 3 and has the following non empty levels
3366 * [0,-1,-2] for example 'm1' lies on TETRA4, HEXA8 TRI3 and SEG2
3367 * - 'f1' lies on 'm1' and is defined on 3D and 1D cells for example
3369 * - 'f2' lies on 'm1' too and is defined on 2D and 1D cells for example TRI3 and SEG2
3371 * In this case f1->getNonEmptyLevelsExt will return (3,[0,-2]) and f2->getNonEmptyLevelsExt will return (2,[0,-1])
3373 * To retrieve the highest level of f1 it should be done, f1->getFieldAtLevel(ON_CELLS,3-3+0);//absDim-meshDim+relativeLev
3374 * To retrieve the lowest level of f1 it should be done, f1->getFieldAtLevel(ON_CELLS,3-3+(-2));//absDim-meshDim+relativeLev
3375 * To retrieve the highest level of f2 it should be done, f1->getFieldAtLevel(ON_CELLS,2-3+0);//absDim-meshDim+relativeLev
3376 * To retrieve the lowest level of f2 it should be done, f1->getFieldAtLevel(ON_CELLS,2-3+(-1));//absDim-meshDim+relativeLev
3378 int MEDFileField1TSWithoutSDA::getNonEmptyLevels(const char *mname, std::vector<int>& levs) const throw(INTERP_KERNEL::Exception)
3381 int meshId=getMeshIdFromMeshName(mname);
3382 std::vector<INTERP_KERNEL::NormalizedCellType> types;
3383 std::vector< std::vector<TypeOfField> > typesF;
3384 std::vector< std::vector<std::string> > pfls, locs;
3385 _field_per_mesh[meshId]->getFieldSplitedByType(types,typesF,pfls,locs);
3387 throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getNonEmptyLevels : 'this' is empty !");
3388 std::set<INTERP_KERNEL::NormalizedCellType> st(types.begin(),types.end());
3389 if(st.size()==1 && (*st.begin())==INTERP_KERNEL::NORM_ERROR)
3391 st.erase(INTERP_KERNEL::NORM_ERROR);
3393 for(std::set<INTERP_KERNEL::NormalizedCellType>::const_iterator it=st.begin();it!=st.end();it++)
3395 const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(*it);
3396 ret1.insert((int)cm.getDimension());
3398 int ret=*std::max_element(ret1.begin(),ret1.end());
3399 std::copy(ret1.rbegin(),ret1.rend(),std::back_insert_iterator<std::vector<int> >(levs));
3400 std::transform(levs.begin(),levs.end(),levs.begin(),std::bind2nd(std::plus<int>(),-ret));
3404 std::vector<TypeOfField> MEDFileField1TSWithoutSDA::getTypesOfFieldAvailable() const throw(INTERP_KERNEL::Exception)
3406 std::vector<TypeOfField> ret;
3407 fillTypesOfFieldAvailable(ret);
3412 * entry point for users that want to iterate into MEDFile DataStructure without any overhead.
3414 std::vector< std::vector< std::pair<int,int> > > MEDFileField1TSWithoutSDA::getFieldSplitedByType(const char *mname, std::vector<INTERP_KERNEL::NormalizedCellType>& types, std::vector< std::vector<TypeOfField> >& typesF, std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> >& locs) const throw(INTERP_KERNEL::Exception)
3418 meshId=getMeshIdFromMeshName(mname);
3420 if(_field_per_mesh.empty())
3421 throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getFieldSplitedByType : This is empty !");
3422 return _field_per_mesh[meshId]->getFieldSplitedByType(types,typesF,pfls,locs);
3426 * entry point for users that want to iterate into MEDFile DataStructure with a reduced overhead because output arrays are extracted (created) specially
3427 * for the call of this method. That's why the DataArrayDouble instance in returned vector of vector should be dealed by the caller.
3429 std::vector< std::vector<DataArrayDouble *> > MEDFileField1TSWithoutSDA::getFieldSplitedByType2(const char *mname, std::vector<INTERP_KERNEL::NormalizedCellType>& types, std::vector< std::vector<TypeOfField> >& typesF, std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> >& locs) const throw(INTERP_KERNEL::Exception)
3433 meshId=getMeshIdFromMeshName(mname);
3435 if(_field_per_mesh.empty())
3436 throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getFieldSplitedByType : This is empty !");
3437 std::vector< std::vector< std::pair<int,int> > > ret0=_field_per_mesh[meshId]->getFieldSplitedByType(types,typesF,pfls,locs);
3438 int nbOfRet=ret0.size();
3439 std::vector< std::vector<DataArrayDouble *> > ret(nbOfRet);
3440 for(int i=0;i<nbOfRet;i++)
3442 const std::vector< std::pair<int,int> >& p=ret0[i];
3443 int nbOfRet1=p.size();
3444 ret[i].resize(nbOfRet1);
3445 for(int j=0;j<nbOfRet1;j++)
3447 DataArrayDouble *tmp=_arr->selectByTupleId2(p[j].first,p[j].second,1);
3454 void MEDFileField1TSWithoutSDA::finishLoading(med_idt fid) throw(INTERP_KERNEL::Exception)
3456 med_int numdt,numit;
3460 med_int meshnumdt,meshnumit;
3461 INTERP_KERNEL::AutoPtr<char> meshName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
3462 MEDfieldComputingStepInfo(fid,getName().c_str(),_csit,&numdt,&numit,&_dt);
3463 MEDfield23ComputingStepMeshInfo(fid,getName().c_str(),_csit,&numdt,&numit,&dt,&nmesh,meshName,&localMesh,&meshnumdt,&meshnumit);
3464 if(_iteration!=numdt || _order!=numit)
3465 throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::finishLoading : unexpected exception internal error !");
3466 _field_per_mesh.resize(nmesh);
3467 for(int i=0;i<nmesh;i++)
3468 _field_per_mesh[i]=MEDFileFieldPerMesh::NewOnRead(fid,this,i+1,meshnumdt,meshnumit);
3470 for(int i=0;i<nmesh;i++)
3472 _field_per_mesh[i]->prepareLoading(fid,start);
3474 getOrCreateAndGetArray()->alloc(start,getNumberOfComponents());
3475 for(int i=0;i<nmesh;i++)
3477 _field_per_mesh[i]->finishLoading(fid,_field_type);
3481 std::vector<std::string> MEDFileField1TSWithoutSDA::getPflsReallyUsed2() const
3483 std::vector<std::string> ret;
3484 std::set<std::string> ret2;
3485 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3487 std::vector<std::string> tmp=(*it)->getPflsReallyUsed();
3488 for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
3489 if(ret2.find(*it2)==ret2.end())
3491 ret.push_back(*it2);
3498 std::vector<std::string> MEDFileField1TSWithoutSDA::getLocsReallyUsed2() const
3500 std::vector<std::string> ret;
3501 std::set<std::string> ret2;
3502 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3504 std::vector<std::string> tmp=(*it)->getLocsReallyUsed();
3505 for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
3506 if(ret2.find(*it2)==ret2.end())
3508 ret.push_back(*it2);
3515 std::vector<std::string> MEDFileField1TSWithoutSDA::getPflsReallyUsedMulti2() const
3517 std::vector<std::string> ret;
3518 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3520 std::vector<std::string> tmp=(*it)->getPflsReallyUsedMulti();
3521 ret.insert(ret.end(),tmp.begin(),tmp.end());
3526 std::vector<std::string> MEDFileField1TSWithoutSDA::getLocsReallyUsedMulti2() const
3528 std::vector<std::string> ret;
3529 std::set<std::string> ret2;
3530 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3532 std::vector<std::string> tmp=(*it)->getLocsReallyUsedMulti();
3533 ret.insert(ret.end(),tmp.begin(),tmp.end());
3538 void MEDFileField1TSWithoutSDA::changePflsRefsNamesGen2(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
3540 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3541 (*it)->changePflsRefsNamesGen(mapOfModif);
3544 void MEDFileField1TSWithoutSDA::changeLocsRefsNamesGen2(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
3546 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3547 (*it)->changeLocsRefsNamesGen(mapOfModif);
3550 void MEDFileField1TSWithoutSDA::writeLL(med_idt fid, const MEDFileWritable& opts) const throw(INTERP_KERNEL::Exception)
3552 if(_field_per_mesh.empty())
3553 throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::writeLL : empty field !");
3554 if(_field_per_mesh.size()>1)
3555 throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::writeLL : In MED3.0 mode in writting mode only ONE underlying mesh supported !");
3556 _field_per_mesh[0]->copyOptionsFrom(opts);
3557 _field_per_mesh[0]->writeLL(fid);
3561 * SBT means Sort By Type.
3562 * This method is the most basic method to assign field in this. Basic in sense that no renumbering is done. Underlying mesh in 'field' is globaly ignored except for type contiguous check.
3564 void MEDFileField1TSWithoutSDA::setFieldNoProfileSBT(const MEDCouplingFieldDouble *field, MEDFileFieldGlobsReal& glob) throw(INTERP_KERNEL::Exception)
3566 const MEDCouplingMesh *mesh=field->getMesh();
3568 TypeOfField type=field->getTypeOfField();
3569 std::vector<DataArrayInt *> dummy;
3570 int start=copyTinyInfoFrom(field);
3571 int pos=addNewEntryIfNecessary(mesh);
3574 std::vector<int> code=MEDFileField1TSWithoutSDA::CheckSBTMesh(mesh);
3575 _field_per_mesh[pos]->assignFieldNoProfileNoRenum(start,code,field,glob);
3578 _field_per_mesh[pos]->assignNodeFieldNoProfile(start,field,glob);
3582 * Generalization of MEDFileField1TSWithoutSDA::setFieldNoProfileSBT method.
3584 void MEDFileField1TSWithoutSDA::setFieldProfile(const MEDCouplingFieldDouble *field, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile, MEDFileFieldGlobsReal& glob) throw(INTERP_KERNEL::Exception)
3586 TypeOfField type=field->getTypeOfField();
3587 int start=copyTinyInfoFrom(field);
3588 std::vector<DataArrayInt *> idsInPflPerType;
3589 std::vector<DataArrayInt *> idsPerType;
3590 std::vector<int> code,code2;
3591 MEDCouplingAutoRefCountObjectPtr<MEDCouplingMesh> m=mesh->getGenMeshAtLevel(meshDimRelToMax);
3594 m->splitProfilePerType(profile,code,idsInPflPerType,idsPerType);
3595 code2=m->getDistributionOfTypes();
3597 std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > idsInPflPerType2(idsInPflPerType.size());
3598 for(std::size_t i=0;i<idsInPflPerType.size();i++)
3599 idsInPflPerType2[i]=idsInPflPerType[i];
3600 std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > idsPerType2(idsPerType.size());
3601 for(std::size_t i=0;i<idsPerType.size();i++)
3602 idsPerType2[i]=idsPerType[i];
3604 int pos=addNewEntryIfNecessary(m);
3605 _field_per_mesh[pos]->assignFieldProfile(start,profile,code,code2,idsInPflPerType,idsPerType,field,m,glob);
3609 int pos=addNewEntryIfNecessary(m);
3610 _field_per_mesh[pos]->assignNodeFieldProfile(start,profile,field,glob);
3614 MEDCouplingFieldDouble *MEDFileField1TSWithoutSDA::getFieldAtLevel(TypeOfField type, int meshDimRelToMax, const char *mName, int renumPol, const MEDFileFieldGlobsReal *glob) const throw(INTERP_KERNEL::Exception)
3616 MEDCouplingAutoRefCountObjectPtr<MEDFileMesh> mm;
3618 mm=MEDFileMesh::New(glob->getFileName(),getMeshName().c_str(),getMeshIteration(),getMeshOrder());
3620 mm=MEDFileMesh::New(glob->getFileName(),mName,getMeshIteration(),getMeshOrder());
3621 return MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,glob,mm);
3624 MEDCouplingFieldDouble *MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel(TypeOfField type, int meshDimRelToMax, int renumPol, const MEDFileFieldGlobsReal *glob, const MEDFileMesh *mesh) const throw(INTERP_KERNEL::Exception)
3626 MEDCouplingAutoRefCountObjectPtr<MEDCouplingMesh> m=mesh->getGenMeshAtLevel(meshDimRelToMax,false);
3627 const DataArrayInt *d=mesh->getNumberFieldAtLevel(meshDimRelToMax);
3628 const DataArrayInt *e=mesh->getNumberFieldAtLevel(1);
3629 if(meshDimRelToMax==1)
3630 (static_cast<MEDCouplingUMesh *>((MEDCouplingMesh *)m))->setMeshDimension(0);
3631 return MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel(type,renumPol,glob,m,d,e);
3634 MEDCouplingFieldDouble *MEDFileField1TSWithoutSDA::getFieldAtTopLevel(TypeOfField type, const char *mName, int renumPol, const MEDFileFieldGlobsReal *glob) const throw(INTERP_KERNEL::Exception)
3636 MEDCouplingAutoRefCountObjectPtr<MEDFileMesh> mm;
3638 mm=MEDFileMesh::New(glob->getFileName(),getMeshName().c_str(),getMeshIteration(),getMeshOrder());
3640 mm=MEDFileMesh::New(glob->getFileName(),mName,getMeshIteration(),getMeshOrder());
3641 int absDim=getDimension();
3642 int meshDimRelToMax=absDim-mm->getMeshDimension();
3643 return MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,glob,mm);
3647 * \param [in] mesh is the whole mesh.
3649 MEDCouplingFieldDouble *MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel(TypeOfField type, int renumPol, const MEDFileFieldGlobsReal *glob, const MEDCouplingMesh *mesh, const DataArrayInt *cellRenum, const DataArrayInt *nodeRenum) const throw(INTERP_KERNEL::Exception)
3651 static const char msg1[]="MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel : request for a renumbered field following mesh numbering whereas it is a profile field !";
3652 int meshId=getMeshIdFromMeshName(mesh->getName());
3654 MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=_field_per_mesh[meshId]->getFieldOnMeshAtLevel(type,glob,mesh,isPfl);
3659 //no need to test _field_per_mesh.empty() because geMeshName has already done it
3666 throw INTERP_KERNEL::Exception(msg1);
3667 //no need to test _field_per_mesh.empty() because geMeshName has already done it
3670 if(cellRenum->getNbOfElems()!=mesh->getNumberOfCells())
3672 std::ostringstream oss; oss << "MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel : Request of simple renumbering but it seems that underlying mesh \"" << mesh->getName() << "\" of requested field ";
3673 oss << "\"" << getName() << "\" has partial renumbering (some geotype has no renumber) !";
3674 throw INTERP_KERNEL::Exception(oss.str().c_str());
3676 ret->renumberCells(cellRenum->getConstPointer(),true);
3683 //no need to test _field_per_mesh.empty() because geMeshName has already done it
3685 throw INTERP_KERNEL::Exception(msg1);
3688 if(nodeRenum->getNbOfElems()!=mesh->getNumberOfNodes())
3690 std::ostringstream oss; oss << "MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel : Request of simple renumbering but it seems that underlying mesh \"" << mesh->getName() << "\" of requested field ";
3691 oss << "\"" << getName() << "\" not defined on all nodes !";
3692 throw INTERP_KERNEL::Exception(oss.str().c_str());
3694 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> nodeRenumSafe=nodeRenum->checkAndPreparePermutation();
3695 ret->renumberNodes(nodeRenumSafe->getConstPointer());
3700 throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel : unsupported renum policy ! Dealing with policy 0 1 2 and 3 !");
3704 DataArrayDouble *MEDFileField1TSWithoutSDA::getFieldWithProfile(TypeOfField type, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt *&pfl, const MEDFileFieldGlobsReal *glob) const throw(INTERP_KERNEL::Exception)
3706 MEDCouplingAutoRefCountObjectPtr<MEDCouplingMesh> m=mesh->getGenMeshAtLevel(meshDimRelToMax);
3707 int meshId=getMeshIdFromMeshName(mesh->getName());
3708 return _field_per_mesh[meshId]->getFieldOnMeshAtLevelWithPfl(type,m,pfl,glob);
3712 * This method retrieves direct access to the underground ParaMEDMEM::DataArrayDouble instance. The returned array is not a newly
3713 * created array so it should \b not be dealed by the caller.
3714 * This method allows to the user a direct access to the values.
3715 * This method is quite unusable if there is more than a nodal field or a cell field on single geometric cell type.
3717 DataArrayDouble *MEDFileField1TSWithoutSDA::getUndergroundDataArray() const throw(INTERP_KERNEL::Exception)
3719 const DataArrayDouble *ret=_arr;
3721 return const_cast<DataArrayDouble *>(ret);
3727 * This method returns an array that the caller must deal with (contrary to those returned by MEDFileField1TSWithoutSDA::getUndergroundDataArray method).
3728 * The returned array is the result of the aggregation of all sub arrays stored in the MED file. So to allow the caller to select the output param
3729 * 'entries' is returned. This output param is a vector of a pair of 2 pairs. The first pair of pair informs of the geometric type it refers to and the discretization
3730 * id attached to it. The second pair of pair precise the range [begin,end) into the returned array.
3731 * This method makes the hypothesis that the field lies only on one mesh. If it is not the case an exception will be thrown.
3733 DataArrayDouble *MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const throw(INTERP_KERNEL::Exception)
3735 if(_field_per_mesh.size()!=1)
3736 throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt : field lies on several meshes, this method has no sense !");
3737 if(_field_per_mesh[0]==0)
3738 throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt : no field specified !");
3739 return _field_per_mesh[0]->getUndergroundDataArrayExt(entries);
3742 MEDFileField1TSWithoutSDA::MEDFileField1TSWithoutSDA(const char *fieldName, int csit, int fieldtype, int iteration, int order,
3743 const std::vector<std::string>& infos):_iteration(iteration),_order(order),_csit(csit),_field_type(fieldtype)
3745 DataArrayDouble *arr=getOrCreateAndGetArray();
3746 arr->setName(fieldName);
3747 arr->setInfoAndChangeNbOfCompo(infos);
3750 MEDFileField1TSWithoutSDA::MEDFileField1TSWithoutSDA():_csit(-1),_field_type(-1)
3754 int MEDFileField1TSWithoutSDA::addNewEntryIfNecessary(const MEDCouplingMesh *mesh) throw(INTERP_KERNEL::Exception)
3756 std::string tmp(mesh->getName());
3758 throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::addNewEntryIfNecessary : empty mesh name ! unsupported by MED file !");
3759 std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();
3761 for(;it!=_field_per_mesh.end();it++,i++)
3763 if((*it)->getMeshName()==tmp)
3766 int sz=_field_per_mesh.size();
3767 _field_per_mesh.resize(sz+1);
3768 _field_per_mesh[sz]=MEDFileFieldPerMesh::New(this,mesh);
3773 * \param [in] mName specifies the underlying mesh name. This value can be pointer 0 for users that do not deal with fields on multi mesh.
3775 int MEDFileField1TSWithoutSDA::getMeshIdFromMeshName(const char *mName) const throw(INTERP_KERNEL::Exception)
3777 if(_field_per_mesh.empty())
3778 throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getMeshIdFromMeshName : No field set !");
3781 std::string mName2(mName);
3783 std::vector<std::string> msg;
3784 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++,ret++)
3785 if(mName2==(*it)->getMeshName())
3788 msg.push_back((*it)->getMeshName());
3789 std::ostringstream oss; oss << "MEDFileField1TSWithoutSDA::getMeshIdFromMeshName : No such mesh \"" << mName2 << "\" as underlying mesh of field \"" << getName() << "\" !\n";
3790 oss << "Possible meshes are : ";
3791 for(std::vector<std::string>::const_iterator it2=msg.begin();it2!=msg.end();it2++)
3792 oss << "\"" << (*it2) << "\" ";
3793 throw INTERP_KERNEL::Exception(oss.str().c_str());
3797 * \param [in] mName specifies the underlying mesh name. This value can be pointer 0 for users that do not deal with fields on multi mesh.
3798 * \param [in] typ is for the geometric cell type (or INTERP_KERNEL::NORM_ERROR for node field) entry to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set.
3799 * \param [in] locId is the localization id to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set. It corresponds to the position of
3800 * \c pfls[std::distance(types.begin(),std::find(types.begin(),typ)] vector in MEDFileField1TSWithoutSDA::getFieldSplitedByType. For non gausspoints field users, the value is 0.
3802 MEDFileFieldPerMeshPerTypePerDisc *MEDFileField1TSWithoutSDA::getLeafGivenMeshAndTypeAndLocId(const char *mName, INTERP_KERNEL::NormalizedCellType typ, int locId) throw(INTERP_KERNEL::Exception)
3804 int mid=getMeshIdFromMeshName(mName);
3805 return _field_per_mesh[mid]->getLeafGivenTypeAndLocId(typ,locId);
3809 * \param [in] mName specifies the underlying mesh name. This value can be pointer 0 for users that do not deal with fields on multi mesh.
3810 * \param [in] typ is for the geometric cell type (or INTERP_KERNEL::NORM_ERROR for node field) entry to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set.
3811 * \param [in] locId is the localization id to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set. It corresponds to the position of
3812 * \c pfls[std::distance(types.begin(),std::find(types.begin(),typ)] vector in MEDFileField1TSWithoutSDA::getFieldSplitedByType. For non gausspoints field users, the value is 0.
3814 const MEDFileFieldPerMeshPerTypePerDisc *MEDFileField1TSWithoutSDA::getLeafGivenMeshAndTypeAndLocId(const char *mName, INTERP_KERNEL::NormalizedCellType typ, int locId) const throw(INTERP_KERNEL::Exception)
3816 int mid=getMeshIdFromMeshName(mName);
3817 return _field_per_mesh[mid]->getLeafGivenTypeAndLocId(typ,locId);
3820 std::size_t MEDFileField1TSWithoutSDA::getHeapMemorySize() const
3822 std::size_t ret=_dt_unit.capacity()+_field_per_mesh.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh >);
3823 if((const DataArrayDouble *)_arr)
3824 ret+=_arr->getHeapMemorySize();
3825 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3826 ret+=(*it)->getHeapMemorySize();
3830 MEDFileField1TSWithoutSDA *MEDFileField1TSWithoutSDA::deepCpy() const throw(INTERP_KERNEL::Exception)
3832 MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA> ret=new MEDFileField1TSWithoutSDA(*this);
3833 if((const DataArrayDouble *)_arr)
3834 ret->_arr=_arr->deepCpy();
3836 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++,i++)
3838 if((const MEDFileFieldPerMesh *)*it)
3839 ret->_field_per_mesh[i]=(*it)->deepCpy((MEDFileField1TSWithoutSDA *)ret);
3844 DataArrayDouble *MEDFileField1TSWithoutSDA::getOrCreateAndGetArray()
3846 DataArrayDouble *ret=_arr;
3849 _arr=DataArrayDouble::New();
3853 const DataArrayDouble *MEDFileField1TSWithoutSDA::getOrCreateAndGetArray() const
3855 const DataArrayDouble *ret=_arr;
3858 DataArrayDouble *ret2=DataArrayDouble::New();
3859 const_cast<MEDFileField1TSWithoutSDA *>(this)->_arr=DataArrayDouble::New();
3863 MEDFileField1TS *MEDFileField1TS::New(const char *fileName, const char *fieldName, int iteration, int order) throw(INTERP_KERNEL::Exception)
3865 return new MEDFileField1TS(fileName,fieldName,iteration,order);
3869 * \warning this is a shallow copy constructor
3871 MEDFileField1TS *MEDFileField1TS::New(const MEDFileField1TSWithoutSDA& other, bool shallowCopyOfContent)
3873 return new MEDFileField1TS(other,shallowCopyOfContent);
3876 MEDFileField1TS *MEDFileField1TS::New()
3878 return new MEDFileField1TS;
3881 std::string MEDFileField1TS::simpleRepr() const
3883 std::ostringstream oss;
3884 _content->simpleRepr(0,oss,-1);
3885 MEDFileFieldGlobsReal::simpleRepr(oss);
3889 void MEDFileField1TS::writeLL(med_idt fid) const throw(INTERP_KERNEL::Exception)
3891 int nbComp=getNumberOfComponents();
3892 INTERP_KERNEL::AutoPtr<char> comp=MEDLoaderBase::buildEmptyString(nbComp*MED_SNAME_SIZE);
3893 INTERP_KERNEL::AutoPtr<char> unit=MEDLoaderBase::buildEmptyString(nbComp*MED_SNAME_SIZE);
3894 for(int i=0;i<nbComp;i++)
3896 std::string info=getInfo()[i];
3898 MEDLoaderBase::splitIntoNameAndUnit(info,c,u);
3899 MEDLoaderBase::safeStrCpy2(c.c_str(),MED_SNAME_SIZE,comp+i*MED_SNAME_SIZE,_too_long_str);
3900 MEDLoaderBase::safeStrCpy2(u.c_str(),MED_SNAME_SIZE,unit+i*MED_SNAME_SIZE,_too_long_str);
3902 if(getName().empty())
3903 throw INTERP_KERNEL::Exception("MEDFileField1TS::write : MED file does not accept field with empty name !");
3904 MEDfieldCr(fid,getName().c_str(),MED_FLOAT64,nbComp,comp,unit,getDtUnit().c_str(),getMeshName().c_str());
3905 writeGlobals(fid,*this);
3906 _content->writeLL(fid,*this);
3909 void MEDFileField1TS::write(const char *fileName, int mode) const throw(INTERP_KERNEL::Exception)
3911 med_access_mode medmod=MEDFileUtilities::TraduceWriteMode(mode);
3912 MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,medmod);
3916 MEDFileField1TS::MEDFileField1TS(const char *fileName, const char *fieldName, int iteration, int order) throw(INTERP_KERNEL::Exception)
3917 try:MEDFileFieldGlobsReal(fileName),_content(MEDFileField1TSWithoutSDA::New(fieldName,-1,-1,iteration,order,std::vector<std::string>()))
3919 MEDFileUtilities::CheckFileForRead(fileName);
3920 MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
3921 int nbFields=MEDnField(fid);
3922 med_field_type typcha;
3924 std::vector<std::string> fns(nbFields);
3926 for(int i=0;i<nbFields && !found;i++)
3928 int ncomp=MEDfieldnComponent(fid,i+1);
3929 INTERP_KERNEL::AutoPtr<char> comp=MEDLoaderBase::buildEmptyString(ncomp*MED_SNAME_SIZE);
3930 INTERP_KERNEL::AutoPtr<char> unit=MEDLoaderBase::buildEmptyString(ncomp*MED_SNAME_SIZE);
3931 INTERP_KERNEL::AutoPtr<char> dtunit=MEDLoaderBase::buildEmptyString(MED_LNAME_SIZE);
3932 INTERP_KERNEL::AutoPtr<char> nomcha=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
3933 INTERP_KERNEL::AutoPtr<char> nomMaa=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
3936 MEDfieldInfo(fid,i+1,nomcha,nomMaa,&localMesh,&typcha,comp,unit,dtunit,&nbOfStep);
3937 std::string tmp(nomcha);
3939 found=(tmp==fieldName);
3943 std::string mname=MEDLoaderBase::buildStringFromFortran(nomMaa,MED_NAME_SIZE);
3944 std::vector<std::string> infos(ncomp);
3945 for(int j=0;j<ncomp;j++)
3946 infos[j]=MEDLoaderBase::buildUnionUnit((char *)comp+j*MED_SNAME_SIZE,MED_SNAME_SIZE,(char *)unit+j*MED_SNAME_SIZE,MED_SNAME_SIZE);
3947 _content->getOrCreateAndGetArray()->setInfoAndChangeNbOfCompo(infos);
3952 std::ostringstream oss; oss << "No such field '" << fieldName << "' in file '" << fileName << "' ! Available fields are : ";
3953 std::copy(fns.begin(),fns.end(),std::ostream_iterator<std::string>(oss," "));
3954 throw INTERP_KERNEL::Exception(oss.str().c_str());
3957 std::vector< std::pair<int,int> > dtits(nbOfStep2);
3958 for(int i=0;i<nbOfStep2 && !found;i++)
3960 med_int numdt,numit;
3962 MEDfieldComputingStepInfo(fid,fieldName,i+1,&numdt,&numit,&dt);
3963 if(numdt==iteration && numit==order)
3966 _content->_csit=i+1;
3967 _content->_field_type=MEDFileUtilities::TraduceFieldType(typcha);
3970 dtits[i]=std::pair<int,int>(numdt,numit);
3974 std::ostringstream oss; oss << "No such iteration (" << iteration << "," << order << ") in existing field '" << fieldName << "' in file '" << fileName << "' ! Available iterations are : ";
3975 for(std::vector< std::pair<int,int> >::const_iterator iter=dtits.begin();iter!=dtits.end();iter++)
3976 oss << "(" << (*iter).first << "," << (*iter).second << "), ";
3977 throw INTERP_KERNEL::Exception(oss.str().c_str());
3979 _content->finishLoading(fid);
3983 catch(INTERP_KERNEL::Exception& e)
3989 * \warning this is a shallow copy constructor
3991 MEDFileField1TS::MEDFileField1TS(const MEDFileField1TSWithoutSDA& other, bool shallowCopyOfContent)
3993 if(!shallowCopyOfContent)
3995 const MEDFileField1TSWithoutSDA *otherPtr(&other);
3996 otherPtr->incrRef();
3997 _content=const_cast<MEDFileField1TSWithoutSDA *>(otherPtr);
4001 _content=new MEDFileField1TSWithoutSDA(other);
4005 MEDFileField1TS::MEDFileField1TS():_content(new MEDFileField1TSWithoutSDA)
4010 * This method returns all profiles whose name is non empty used.
4011 * \b WARNING If profile is used several times it will be reported \b only \b once.
4012 * To get non empty name profiles as time as they appear in \b this call MEDFileField1TS::getPflsReallyUsedMulti instead.
4014 std::vector<std::string> MEDFileField1TS::getPflsReallyUsed() const
4016 return _content->getPflsReallyUsed2();
4020 * This method returns all localizations whose name is non empty used.
4021 * \b WARNING If localization is used several times it will be reported \b only \b once.
4023 std::vector<std::string> MEDFileField1TS::getLocsReallyUsed() const
4025 return _content->getLocsReallyUsed2();
4029 * This method returns all profiles whose name is non empty used.
4030 * \b WARNING contrary to MEDFileField1TS::getPflsReallyUsed, if profile is used several times it will be reported as time as it appears.
4032 std::vector<std::string> MEDFileField1TS::getPflsReallyUsedMulti() const
4034 return _content->getPflsReallyUsedMulti2();
4038 * This method returns all localizations whose name is non empty used.
4039 * \b WARNING contrary to MEDFileField1TS::getLocsReallyUsed if localization is used several times it will be reported as time as it appears.
4041 std::vector<std::string> MEDFileField1TS::getLocsReallyUsedMulti() const
4043 return _content->getLocsReallyUsedMulti2();
4046 void MEDFileField1TS::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
4048 _content->changePflsRefsNamesGen2(mapOfModif);
4051 void MEDFileField1TS::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
4053 _content->changeLocsRefsNamesGen2(mapOfModif);
4057 * This method requests underlying file to perform the job, for mesh reading. If the current instance is not coming from a file and has been constructed from scratch
4058 * an exception will be thrown. In this case you should use MEDFileField1TS::getFieldOnMeshAtLevel method instead.
4059 * \b WARNING ! Parameter 'meshDimRelToMax' is relative from read mesh in file that can be different from the field in MED file !
4060 * It leads that the returned field of this method is always coherent.
4062 MEDCouplingFieldDouble *MEDFileField1TS::getFieldAtLevel(TypeOfField type, int meshDimRelToMax, int renumPol) const throw(INTERP_KERNEL::Exception)
4064 if(getFileName2().empty())
4065 throw INTERP_KERNEL::Exception("MEDFileField1TS::getFieldAtLevel : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtLevel method instead !");
4066 return _content->getFieldAtLevel(type,meshDimRelToMax,0,renumPol,this);
4070 * This method is close to MEDFileField1TS::getFieldAtLevel except that here the 'meshDimRelToMax' param is ignored and the maximal dimension is taken
4071 * automatically. If the field lies on different level and that an another level than the maximal is requested MEDFileField1TS::getFieldAtLevel
4072 * should be called instead.
4074 MEDCouplingFieldDouble *MEDFileField1TS::getFieldAtTopLevel(TypeOfField type, int renumPol) const throw(INTERP_KERNEL::Exception)
4076 if(getFileName2().empty())
4077 throw INTERP_KERNEL::Exception("MEDFileField1TS::getFieldAtTopLevel : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtTopLevel method instead !");
4078 return _content->getFieldAtTopLevel(type,0,renumPol,this);
4082 * \b WARNING, there is a main difference with the two close methods (MEDFileField1TS::getFieldAtLevel and MEDFileField1TS::getFieldOnMeshAtLevel method) !
4083 * Here the mesh-dimension of 'mesh' is used by this to automatically request the right geoTypes regarding 'type'.
4084 * If no such element fufilled the deduced dimension and 'type' an exception will be thrown.
4085 * It leads that the returned field of this method is always coherent.
4087 MEDCouplingFieldDouble *MEDFileField1TS::getFieldOnMeshAtLevel(TypeOfField type, const MEDCouplingMesh *mesh, int renumPol) const throw(INTERP_KERNEL::Exception)
4089 return _content->getFieldOnMeshAtLevel(type,renumPol,this,mesh,0,0);
4093 * This method can be called whatever the mode of instance feeding of this (MED file or from scratch).
4094 * But the parameter ''meshDimRelToMax' is applyied on 'mesh' (like MEDFileField1TS::getFieldAtLevel does). \b WARNING the dim of 'this' can be different from those in 'mesh' !
4095 * It leads that the returned field of this method is always coherent.
4097 MEDCouplingFieldDouble *MEDFileField1TS::getFieldOnMeshAtLevel(TypeOfField type, int meshDimRelToMax, const MEDFileMesh *mesh, int renumPol) const throw(INTERP_KERNEL::Exception)
4099 return _content->getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,this,mesh);
4103 * This method is identical to MEDFileField1TS::getFieldAtLevel method except that meshName 'mname' should be specified.
4104 * This method is called "Old" because in MED3 norm a field has only one meshName attached. This method is only here for reader of MED2 files.
4105 * See MEDFileField1TS::getFieldAtLevel for more information.
4107 MEDCouplingFieldDouble *MEDFileField1TS::getFieldAtLevelOld(TypeOfField type, const char *mname, int meshDimRelToMax, int renumPol) const throw(INTERP_KERNEL::Exception)
4109 if(getFileName2().empty())
4110 throw INTERP_KERNEL::Exception("MEDFileField1TS::getFieldAtLevel : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtLevel method instead !");
4111 return _content->getFieldAtLevel(type,meshDimRelToMax,mname,renumPol,this);
4114 DataArrayDouble *MEDFileField1TS::getFieldWithProfile(TypeOfField type, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt *&pfl) const throw(INTERP_KERNEL::Exception)
4116 return _content->getFieldWithProfile(type,meshDimRelToMax,mesh,pfl,this);
4120 * SBT means Sort By Type.
4121 * This method is the most basic method to assign field in this. Basic in sense that no renumbering is done. Underlying mesh in 'field' is globaly ignored except for type contiguous check.
4124 void MEDFileField1TS::setFieldNoProfileSBT(const MEDCouplingFieldDouble *field) throw(INTERP_KERNEL::Exception)
4127 _content->setFieldNoProfileSBT(field,*this);
4131 * This method is a generalization of MEDFileField1TS::setFieldNoProfileSBT method. Here a profile array is given in input.
4132 * The support of field 'field' is \b not used by this method, so it can be null or incoherent with field.
4133 * This method uses input parameters 'mesh', 'meshDimRelToMax' and 'profile' to determine what is really the support of field 'field'. If field is incoherent regarding this deduced support,
4134 * an exception will be thrown.
4135 * This method is trying to reduce the size of MEDfile file so profile is created only if it is absolutely necessary. If it is necessary the name of 'profile' will be used to create it in 'this'.
4136 * In this case, if this profile name is empty an exception will be thrown.
4138 void MEDFileField1TS::setFieldProfile(const MEDCouplingFieldDouble *field, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile) throw(INTERP_KERNEL::Exception)
4141 _content->setFieldProfile(field,mesh,meshDimRelToMax,profile,*this);
4145 * This method as MEDFileField1TSW::setLocNameOnLeaf, is dedicated for advanced user that a want a very fine control on their data structure
4146 * without overhead. This method can be called only regarding information returned by MEDFileField1TSWithoutSDA::getFieldSplitedByType or MEDFileField1TSWithoutSDA::getFieldSplitedByType2.
4147 * This method changes the attribute (here it's profile name) of the leaf datastructure (MEDFileFieldPerMeshPerTypePerDisc instance).
4148 * It is the responsability of the caller to invoke MEDFileFieldGlobs::appendProfile or MEDFileFieldGlobs::getProfile
4149 * to keep a valid instance.
4150 * If \b this do not have any leaf that correspond to the request of the input parameter (\b mName, \b typ, \b locId) an INTERP_KERNEL::Exception will be thrown.
4151 * If \b newPflName profile name does not already exist the profile with old name will be renamed with name \b newPflName.
4152 * If \b newPflName already exists and that \b forceRenameOnGlob is false (the default) an INTERP_KERNEL::Exception will be thrown to avoid big confusion. In this case the called should rename before the profile name with name \b newPflName.
4154 * \param [in] mName specifies the underlying mesh name. This value can be pointer 0 for users that do not deal with fields on multi mesh.
4155 * \param [in] typ is for the geometric cell type (or INTERP_KERNEL::NORM_ERROR for node field) entry to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set.
4156 * \param [in] locId is the localization id to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set. It corresponds to the position of
4157 * \c pfls[std::distance(types.begin(),std::find(types.begin(),typ)] vector in MEDFileField1TSWithoutSDA::getFieldSplitedByType. For non gausspoints field users, the value is 0.
4158 * \param [in] newLocName is the new localization name.
4159 * \param [in] forceRenameOnGlob specifies the behaviour in case of profile \b newPflName already exists. If true, the renaming is done without check. It can lead to major bug.
4160 * If false, an exception will be thrown to force user to change previously the name of the profile with name \b newPflName
4162 void MEDFileField1TS::setProfileNameOnLeaf(const char *mName, INTERP_KERNEL::NormalizedCellType typ, int locId, const char *newPflName, bool forceRenameOnGlob) throw(INTERP_KERNEL::Exception)
4164 MEDFileFieldPerMeshPerTypePerDisc *disc=getLeafGivenMeshAndTypeAndLocId(mName,typ,locId);
4165 std::string oldPflName=disc->getProfile();
4166 std::vector<std::string> vv=getPflsReallyUsedMulti();
4167 int nbOfOcc=std::count(vv.begin(),vv.end(),oldPflName);
4168 if(forceRenameOnGlob || (!existsPfl(newPflName) && nbOfOcc==1))
4170 disc->setProfile(newPflName);
4171 DataArrayInt *pfl=getProfile(oldPflName.c_str());
4172 pfl->setName(newPflName);
4176 std::ostringstream oss; oss << "MEDFileField1TS::setProfileNameOnLeaf : Profile \"" << newPflName << "\" already exists or referenced more than one !";
4177 throw INTERP_KERNEL::Exception(oss.str().c_str());
4182 * This method as MEDFileField1TSW::setProfileNameOnLeaf, is dedicated for advanced user that a want a very fine control on their data structure
4183 * without overhead. This method can be called only regarding information returned by MEDFileField1TSWithoutSDA::getFieldSplitedByType or MEDFileField1TSWithoutSDA::getFieldSplitedByType2.
4184 * This method changes the attribute (here it's localization name) of the leaf datastructure (MEDFileFieldPerMeshPerTypePerDisc instance).
4185 * It is the responsability of the caller to invoke MEDFileFieldGlobs::appendProfile or MEDFileFieldGlobs::getProfile
4186 * to keep a valid instance.
4187 * If \b this do not have any leaf that correspond to the request of the input parameter (\b mName, \b typ, \b locId) an INTERP_KERNEL::Exception will be thrown.
4188 * This method is an extension of MEDFileField1TSWithoutSDA::setProfileNameOnLeafExt method because it performs a modification of global info.
4189 * If \b newLocName profile name does not already exist the localization with old name will be renamed with name \b newLocName.
4190 * If \b newLocName already exists an INTERP_KERNEL::Exception will be thrown to avoid big confusion. In this case the called should rename before the profile name with name \b newLocName.
4192 * \param [in] mName specifies the underlying mesh name. This value can be pointer 0 for users that do not deal with fields on multi mesh.
4193 * \param [in] typ is for the geometric cell type (or INTERP_KERNEL::NORM_ERROR for node field) entry to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set.
4194 * \param [in] locId is the localization id to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set. It corresponds to the position of
4195 * \c pfls[std::distance(types.begin(),std::find(types.begin(),typ)] vector in MEDFileField1TSWithoutSDA::getFieldSplitedByType. For non gausspoints field users, the value is 0.
4196 * \param [in] newLocName is the new localization name.
4197 * \param [in] forceRenameOnGlob specifies the behaviour in case of profile \b newLocName already exists. If true, the renaming is done without check. It can lead to major bug.
4198 * If false, an exception will be thrown to force user to change previously the name of the profile with name \b newLocName
4200 void MEDFileField1TS::setLocNameOnLeaf(const char *mName, INTERP_KERNEL::NormalizedCellType typ, int locId, const char *newLocName, bool forceRenameOnGlob) throw(INTERP_KERNEL::Exception)
4202 MEDFileFieldPerMeshPerTypePerDisc *disc=getLeafGivenMeshAndTypeAndLocId(mName,typ,locId);
4203 std::string oldLocName=disc->getLocalization();
4204 std::vector<std::string> vv=getLocsReallyUsedMulti();
4205 int nbOfOcc=std::count(vv.begin(),vv.end(),oldLocName);
4206 if(forceRenameOnGlob || (!existsLoc(newLocName) && nbOfOcc==1))
4208 disc->setLocalization(newLocName);
4209 MEDFileFieldLoc& loc=getLocalization(oldLocName.c_str());
4210 loc.setName(newLocName);
4214 std::ostringstream oss; oss << "MEDFileField1TS::setLocNameOnLeaf : Localization \"" << newLocName << "\" already exists or referenced more than one !";
4215 throw INTERP_KERNEL::Exception(oss.str().c_str());
4219 std::size_t MEDFileField1TS::getHeapMemorySize() const
4222 if((const MEDFileField1TSWithoutSDA *)_content)
4223 ret+=_content->getHeapMemorySize();
4224 return ret+MEDFileFieldGlobsReal::getHeapMemorySize();
4227 MEDFileField1TS *MEDFileField1TS::deepCpy() const throw(INTERP_KERNEL::Exception)
4229 MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=new MEDFileField1TS(*this);
4230 if((const MEDFileField1TSWithoutSDA *)_content)
4231 ret->_content=_content->deepCpy();
4232 ret->deepCpyGlobs(*this);
4236 int MEDFileField1TS::copyTinyInfoFrom(const MEDCouplingFieldDouble *field) throw(INTERP_KERNEL::Exception)
4238 return _content->copyTinyInfoFrom(field);
4241 int MEDFileField1TS::getDimension() const
4243 return _content->getDimension();
4246 int MEDFileField1TS::getIteration() const
4248 return _content->getIteration();
4251 int MEDFileField1TS::getOrder() const
4253 return _content->getOrder();
4256 double MEDFileField1TS::getTime(int& iteration, int& order) const
4258 return _content->getTime(iteration,order);
4261 void MEDFileField1TS::setTime(int iteration, int order, double val)
4263 _content->setTime(iteration,order,val);
4266 std::string MEDFileField1TS::getName() const
4268 return _content->getName();
4271 void MEDFileField1TS::setName(const char *name)
4273 _content->setName(name);
4276 void MEDFileField1TS::simpleRepr(int bkOffset, std::ostream& oss, int f1tsId) const
4278 _content->simpleRepr(bkOffset,oss,f1tsId);
4281 const std::string& MEDFileField1TS::getDtUnit() const
4283 return _content->getDtUnit();
4286 std::string MEDFileField1TS::getMeshName() const throw(INTERP_KERNEL::Exception)
4288 return _content->getMeshName();
4291 void MEDFileField1TS::setMeshName(const char *newMeshName) throw(INTERP_KERNEL::Exception)
4293 _content->setMeshName(newMeshName);
4296 bool MEDFileField1TS::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab) throw(INTERP_KERNEL::Exception)
4298 return _content->changeMeshNames(modifTab);
4301 int MEDFileField1TS::getMeshIteration() const throw(INTERP_KERNEL::Exception)
4303 return _content->getMeshIteration();
4306 int MEDFileField1TS::getMeshOrder() const throw(INTERP_KERNEL::Exception)
4308 return _content->getMeshOrder();
4311 int MEDFileField1TS::getNumberOfComponents() const
4313 return _content->getNumberOfComponents();
4316 bool MEDFileField1TS::isDealingTS(int iteration, int order) const
4318 return _content->isDealingTS(iteration,order);
4321 std::pair<int,int> MEDFileField1TS::getDtIt() const
4323 return _content->getDtIt();
4326 void MEDFileField1TS::fillIteration(std::pair<int,int>& p) const
4328 _content->fillIteration(p);
4330 void MEDFileField1TS::fillTypesOfFieldAvailable(std::vector<TypeOfField>& types) const throw(INTERP_KERNEL::Exception)
4332 _content->fillTypesOfFieldAvailable(types);
4335 const std::vector<std::string>& MEDFileField1TS::getInfo() const
4337 return _content->getInfo();
4339 std::vector<std::string>& MEDFileField1TS::getInfo()
4341 return _content->getInfo();
4344 DataArrayDouble *MEDFileField1TS::getUndergroundDataArray() const throw(INTERP_KERNEL::Exception)
4346 return _content->getUndergroundDataArray();
4349 DataArrayDouble *MEDFileField1TS::getUndergroundDataArrayExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const throw(INTERP_KERNEL::Exception)
4351 return _content->getUndergroundDataArrayExt(entries);
4354 MEDFileFieldPerMeshPerTypePerDisc *MEDFileField1TS::getLeafGivenMeshAndTypeAndLocId(const char *mName, INTERP_KERNEL::NormalizedCellType typ, int locId) throw(INTERP_KERNEL::Exception)
4356 return _content->getLeafGivenMeshAndTypeAndLocId(mName,typ,locId);
4359 const MEDFileFieldPerMeshPerTypePerDisc *MEDFileField1TS::getLeafGivenMeshAndTypeAndLocId(const char *mName, INTERP_KERNEL::NormalizedCellType typ, int locId) const throw(INTERP_KERNEL::Exception)
4361 return _content->getLeafGivenMeshAndTypeAndLocId(mName,typ,locId);
4364 int MEDFileField1TS::getNonEmptyLevels(const char *mname, std::vector<int>& levs) const throw(INTERP_KERNEL::Exception)
4366 return _content->getNonEmptyLevels(mname,levs);
4369 std::vector<TypeOfField> MEDFileField1TS::getTypesOfFieldAvailable() const throw(INTERP_KERNEL::Exception)
4371 return _content->getTypesOfFieldAvailable();
4374 std::vector< std::vector<std::pair<int,int> > > MEDFileField1TS::getFieldSplitedByType(const char *mname, std::vector<INTERP_KERNEL::NormalizedCellType>& types, std::vector< std::vector<TypeOfField> >& typesF,
4375 std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> >& locs) const throw(INTERP_KERNEL::Exception)
4377 return _content->getFieldSplitedByType(mname,types,typesF,pfls,locs);
4379 std::vector< std::vector<DataArrayDouble *> > MEDFileField1TS::getFieldSplitedByType2(const char *mname, std::vector<INTERP_KERNEL::NormalizedCellType>& types, std::vector< std::vector<TypeOfField> >& typesF,
4380 std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> >& locs) const throw(INTERP_KERNEL::Exception)
4382 return _content->getFieldSplitedByType2(mname,types,typesF,pfls,locs);
4385 MEDFileFieldMultiTSWithoutSDA *MEDFileFieldMultiTSWithoutSDA::New(med_idt fid, const char *fieldName, int id, int ft, const std::vector<std::string>& infos, int nbOfStep) throw(INTERP_KERNEL::Exception)
4387 return new MEDFileFieldMultiTSWithoutSDA(fid,fieldName,id,ft,infos,nbOfStep);
4390 MEDFileFieldMultiTSWithoutSDA::MEDFileFieldMultiTSWithoutSDA():_field_type(-1)
4394 MEDFileFieldMultiTSWithoutSDA::MEDFileFieldMultiTSWithoutSDA(const char *fieldName):_name(fieldName),_field_type(-1)
4399 * \param [in] fieldId field id in C mode
4401 MEDFileFieldMultiTSWithoutSDA::MEDFileFieldMultiTSWithoutSDA(med_idt fid, int fieldId) throw(INTERP_KERNEL::Exception)
4404 med_field_type typcha;
4406 int ncomp=MEDfieldnComponent(fid,fieldId+1);
4407 INTERP_KERNEL::AutoPtr<char> comp=MEDLoaderBase::buildEmptyString(ncomp*MED_SNAME_SIZE);
4408 INTERP_KERNEL::AutoPtr<char> unit=MEDLoaderBase::buildEmptyString(ncomp*MED_SNAME_SIZE);
4409 INTERP_KERNEL::AutoPtr<char> dtunit=MEDLoaderBase::buildEmptyString(MED_LNAME_SIZE);
4410 INTERP_KERNEL::AutoPtr<char> nomcha=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
4411 INTERP_KERNEL::AutoPtr<char> nomMaa=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
4414 MEDfieldInfo(fid,fieldId+1,nomcha,nomMaa,&localMesh,&typcha,comp,unit,dtunit,&nbOfStep);
4415 _name=MEDLoaderBase::buildStringFromFortran(nomcha,MED_NAME_SIZE);
4416 _field_type=MEDFileUtilities::TraduceFieldType(typcha);
4417 _infos.resize(ncomp);
4418 for(int j=0;j<ncomp;j++)
4419 _infos[j]=MEDLoaderBase::buildUnionUnit((char *)comp+j*MED_SNAME_SIZE,MED_SNAME_SIZE,(char *)unit+j*MED_SNAME_SIZE,MED_SNAME_SIZE);
4421 finishLoading(fid,nbOfStep);
4423 catch(INTERP_KERNEL::Exception& e)
4428 MEDFileFieldMultiTSWithoutSDA::MEDFileFieldMultiTSWithoutSDA(med_idt fid, const char *fieldName, int id, int ft, const std::vector<std::string>& infos, int nbOfStep) throw(INTERP_KERNEL::Exception)
4429 try:_name(fieldName),_infos(infos),_field_type(ft)
4431 finishLoading(fid,nbOfStep);
4433 catch(INTERP_KERNEL::Exception& e)
4438 std::size_t MEDFileFieldMultiTSWithoutSDA::getHeapMemorySize() const
4440 std::size_t ret=_name.capacity()+_infos.capacity()*sizeof(std::string)+_time_steps.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA>);
4441 for(std::vector<std::string>::const_iterator it=_infos.begin();it!=_infos.end();it++)
4442 ret+=(*it).capacity();
4443 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
4444 if((const MEDFileField1TSWithoutSDA *)(*it))
4445 ret+=(*it)->getHeapMemorySize();
4449 MEDFileFieldMultiTSWithoutSDA *MEDFileFieldMultiTSWithoutSDA::deepCpy() const throw(INTERP_KERNEL::Exception)
4451 MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTSWithoutSDA> ret=new MEDFileFieldMultiTSWithoutSDA(*this);
4453 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,i++)
4455 if((const MEDFileField1TSWithoutSDA *)*it)
4456 ret->_time_steps[i]=(*it)->deepCpy();
4461 const std::vector<std::string>& MEDFileFieldMultiTSWithoutSDA::getInfo() const throw(INTERP_KERNEL::Exception)
4463 if(_time_steps.empty())
4464 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::getInfos : not time steps !");
4465 return _time_steps[0]->getInfo();
4469 * See doc at MEDFileField1TSWithoutSDA::getUndergroundDataArray
4471 DataArrayDouble *MEDFileFieldMultiTSWithoutSDA::getUndergroundDataArray(int iteration, int order) const throw(INTERP_KERNEL::Exception)
4473 return getTimeStepEntry(iteration,order).getUndergroundDataArray();
4477 * See doc at MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt
4479 DataArrayDouble *MEDFileFieldMultiTSWithoutSDA::getUndergroundDataArrayExt(int iteration, int order, std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const throw(INTERP_KERNEL::Exception)
4481 return getTimeStepEntry(iteration,order).getUndergroundDataArrayExt(entries);
4484 std::string MEDFileFieldMultiTSWithoutSDA::getMeshName() const throw(INTERP_KERNEL::Exception)
4486 if(_time_steps.empty())
4487 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::getMeshName : not time steps !");
4488 return _time_steps[0]->getMeshName();
4491 void MEDFileFieldMultiTSWithoutSDA::setMeshName(const char *newMeshName) throw(INTERP_KERNEL::Exception)
4493 std::string oldName(getMeshName());
4494 std::vector< std::pair<std::string,std::string> > v(1);
4495 v[0].first=oldName; v[0].second=newMeshName;
4499 bool MEDFileFieldMultiTSWithoutSDA::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab) throw(INTERP_KERNEL::Exception)
4502 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
4504 MEDFileField1TSWithoutSDA *cur(*it);
4506 ret=cur->changeMeshNames(modifTab) || ret;
4511 bool MEDFileFieldMultiTSWithoutSDA::renumberEntitiesLyingOnMesh(const char *meshName, const std::vector<int>& oldCode, const std::vector<int>& newCode, const DataArrayInt *renumO2N,
4512 MEDFileFieldGlobsReal& glob) throw(INTERP_KERNEL::Exception)
4515 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
4517 MEDFileField1TSWithoutSDA *f1ts(*it);
4519 ret=f1ts->renumberEntitiesLyingOnMesh(meshName,oldCode,newCode,renumO2N,glob) || ret;
4524 void MEDFileFieldMultiTSWithoutSDA::appendFieldNoProfileSBT(const MEDCouplingFieldDouble *field, MEDFileFieldGlobsReal& glob) throw(INTERP_KERNEL::Exception)
4526 if(_time_steps.empty())
4528 MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA> obj=new MEDFileField1TSWithoutSDA;
4529 obj->setFieldNoProfileSBT(field,glob);
4530 copyTinyInfoFrom(field);
4531 _time_steps.push_back(obj);
4535 checkCoherencyOfTinyInfo(field);
4536 MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA> obj=new MEDFileField1TSWithoutSDA;
4537 obj->setFieldNoProfileSBT(field,glob);
4538 _time_steps.push_back(obj);
4542 void MEDFileFieldMultiTSWithoutSDA::appendFieldProfile(const MEDCouplingFieldDouble *field, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile, MEDFileFieldGlobsReal& glob) throw(INTERP_KERNEL::Exception)
4544 if(_time_steps.empty())
4546 MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA> obj=new MEDFileField1TSWithoutSDA;
4547 obj->setFieldProfile(field,mesh,meshDimRelToMax,profile,glob);
4548 copyTinyInfoFrom(field);
4549 _time_steps.push_back(obj);
4553 checkCoherencyOfTinyInfo(field);
4554 MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA> obj=new MEDFileField1TSWithoutSDA;
4555 obj->setFieldProfile(field,mesh,meshDimRelToMax,profile,glob);
4556 _time_steps.push_back(obj);
4560 std::string MEDFileFieldMultiTSWithoutSDA::getDtUnit() const throw(INTERP_KERNEL::Exception)
4562 if(_time_steps.empty())
4563 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::getMeshName : not time steps !");
4564 return _time_steps[0]->getDtUnit();
4567 std::string MEDFileFieldMultiTSWithoutSDA::getName() const
4572 void MEDFileFieldMultiTSWithoutSDA::setName(const char *name)
4577 void MEDFileFieldMultiTSWithoutSDA::simpleRepr(int bkOffset, std::ostream& oss, int fmtsId) const
4579 std::string startLine(bkOffset,' ');
4580 oss << startLine << "Field multi time steps";
4582 oss << " (" << fmtsId << ")";
4583 oss << " has the following name: \"" << _name << "\"." << std::endl;
4584 oss << startLine << "Field multi time steps has " << _infos.size() << " components with the following infos :" << std::endl;
4585 for(std::vector<std::string>::const_iterator it=_infos.begin();it!=_infos.end();it++)
4587 oss << startLine << " - \"" << *it << "\"" << std::endl;
4590 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,i++)
4592 std::string chapter(17,'0'+i);
4593 oss << startLine << chapter << std::endl;
4594 const MEDFileField1TSWithoutSDA *cur=(*it);
4596 cur->simpleRepr(bkOffset+2,oss,i);
4598 oss << startLine << " Field on one time step #" << i << " is not defined !" << std::endl;
4599 oss << startLine << chapter << std::endl;
4603 std::vector< std::pair<int,int> > MEDFileFieldMultiTSWithoutSDA::getTimeSteps(std::vector<double>& ret1) const throw(INTERP_KERNEL::Exception)
4605 std::size_t sz=_time_steps.size();
4606 std::vector< std::pair<int,int> > ret(sz);
4608 for(std::size_t i=0;i<sz;i++)
4610 const MEDFileField1TSWithoutSDA *f1ts=_time_steps[i];
4613 ret1[i]=f1ts->getTime(ret[i].first,ret[i].second);
4617 std::ostringstream oss; oss << "MEDFileFieldMultiTSWithoutSDA::getTimeSteps : At rank #" << i << " time step is not defined. Invoke eraseEmptyTS method !";
4618 throw INTERP_KERNEL::Exception(oss.str().c_str());
4624 void MEDFileFieldMultiTSWithoutSDA::finishLoading(med_idt fid, int nbPdt) throw(INTERP_KERNEL::Exception)
4626 _time_steps.resize(nbPdt);
4627 for(int i=0;i<nbPdt;i++)
4629 std::vector< std::pair<int,int> > ts;
4630 med_int numdt=0,numo=0;
4631 med_int meshIt=0,meshOrder=0;
4633 MEDfieldComputingStepMeshInfo(fid,_name.c_str(),i+1,&numdt,&numo,&dt,&meshIt,&meshOrder);
4634 _time_steps[i]=MEDFileField1TSWithoutSDA::New(_name.c_str(),i+1,_field_type,numdt,numo,_infos);
4635 _time_steps[i]->finishLoading(fid);
4639 void MEDFileFieldMultiTSWithoutSDA::copyTinyInfoFrom(const MEDCouplingFieldDouble *field) throw(INTERP_KERNEL::Exception)
4641 _name=field->getName();
4643 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::copyTinyInfoFrom : unsupported fields with no name in MED file !");
4644 const DataArrayDouble *arr=field->getArray();
4646 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::copyTinyInfoFrom : no array set !");
4647 _infos=arr->getInfoOnComponents();
4650 void MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfTinyInfo(const MEDCouplingFieldDouble *field) const throw(INTERP_KERNEL::Exception)
4652 static const char MSG[]="MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfTinyInfo : invalid ";
4653 if(_name!=field->getName())
4655 std::ostringstream oss; oss << MSG << "name ! should be \"" << _name;
4656 oss << "\" and it is set in input field to \"" << field->getName() << "\" !";
4657 throw INTERP_KERNEL::Exception(oss.str().c_str());
4659 const DataArrayDouble *arr=field->getArray();
4661 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfTinyInfo : no array set !");
4662 if(_infos!=arr->getInfoOnComponents())
4664 std::ostringstream oss; oss << MSG << "components ! should be \"";
4665 std::copy(_infos.begin(),_infos.end(),std::ostream_iterator<std::string>(oss,", "));
4666 oss << " But compo in input fields are : ";
4667 std::vector<std::string> tmp=arr->getInfoOnComponents();
4668 std::copy(tmp.begin(),tmp.end(),std::ostream_iterator<std::string>(oss,", "));
4670 throw INTERP_KERNEL::Exception(oss.str().c_str());
4674 void MEDFileFieldMultiTSWithoutSDA::writeLL(med_idt fid, const MEDFileWritable& opts) const throw(INTERP_KERNEL::Exception)
4676 if(_time_steps.empty())
4677 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::writeLL : no time steps set !");
4678 std::vector<std::string> infos(getInfo());
4679 int nbComp=infos.size();
4680 INTERP_KERNEL::AutoPtr<char> comp=MEDLoaderBase::buildEmptyString(nbComp*MED_SNAME_SIZE);
4681 INTERP_KERNEL::AutoPtr<char> unit=MEDLoaderBase::buildEmptyString(nbComp*MED_SNAME_SIZE);
4682 for(int i=0;i<nbComp;i++)
4684 std::string info=infos[i];
4686 MEDLoaderBase::splitIntoNameAndUnit(info,c,u);
4687 MEDLoaderBase::safeStrCpy2(c.c_str(),MED_SNAME_SIZE,comp+i*MED_SNAME_SIZE,opts.getTooLongStrPolicy());
4688 MEDLoaderBase::safeStrCpy2(u.c_str(),MED_SNAME_SIZE,unit+i*MED_SNAME_SIZE,opts.getTooLongStrPolicy());
4691 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::write : MED file does not accept field with empty name !");
4692 MEDfieldCr(fid,_name.c_str(),MED_FLOAT64,nbComp,comp,unit,getDtUnit().c_str(),getMeshName().c_str());
4693 int nbOfTS=_time_steps.size();
4694 for(int i=0;i<nbOfTS;i++)
4695 _time_steps[i]->writeLL(fid,opts);
4698 int MEDFileFieldMultiTSWithoutSDA::getNumberOfTS() const
4700 return _time_steps.size();
4703 void MEDFileFieldMultiTSWithoutSDA::eraseEmptyTS() throw(INTERP_KERNEL::Exception)
4705 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA> > newTS;
4706 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
4708 const MEDFileField1TSWithoutSDA *tmp=(*it);
4710 newTS.push_back(*it);
4715 void MEDFileFieldMultiTSWithoutSDA::eraseTimeStepIds(const int *startIds, const int *endIds) throw(INTERP_KERNEL::Exception)
4717 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA> > newTS;
4718 int maxId=(int)_time_steps.size();
4720 std::set<int> idsToDel;
4721 for(const int *id=startIds;id!=endIds;id++,ii++)
4723 if(*id>=0 && *id<maxId)
4725 idsToDel.insert(*id);
4729 std::ostringstream oss; oss << "MEDFileFieldMultiTSWithoutSDA::eraseTimeStepIds : At pos #" << ii << " request for id=" << *id << " not in [0," << maxId << ") !";
4730 throw INTERP_KERNEL::Exception(oss.str().c_str());
4733 for(int iii=0;iii<maxId;iii++)
4734 if(idsToDel.find(iii)==idsToDel.end())
4735 newTS.push_back(_time_steps[iii]);
4739 int MEDFileFieldMultiTSWithoutSDA::getPosOfTimeStep(int iteration, int order) const throw(INTERP_KERNEL::Exception)
4742 std::ostringstream oss; oss << "MEDFileFieldMultiTSWithoutSDA::getPosOfTimeStep : No such time step (" << iteration << "," << order << ") !\nPossibilities are : ";
4743 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,ret++)
4745 const MEDFileField1TSWithoutSDA *tmp(*it);
4749 tmp->getTime(it2,ord);
4750 if(it2==iteration && order==ord)
4753 oss << "(" << it2 << "," << ord << "), ";
4756 throw INTERP_KERNEL::Exception(oss.str().c_str());
4759 int MEDFileFieldMultiTSWithoutSDA::getPosGivenTime(double time, double eps) const throw(INTERP_KERNEL::Exception)
4762 std::ostringstream oss; oss << "MEDFileFieldMultiTSWithoutSDA::getPosGivenTime : No such time step " << time << "! \nPossibilities are : ";
4764 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,ret++)
4766 const MEDFileField1TSWithoutSDA *tmp(*it);
4770 double ti=tmp->getTime(it2,ord);
4771 if(fabs(time-ti)<eps)
4777 throw INTERP_KERNEL::Exception(oss.str().c_str());
4780 std::vector< std::pair<int,int> > MEDFileFieldMultiTSWithoutSDA::getIterations() const
4782 int lgth=_time_steps.size();
4783 std::vector< std::pair<int,int> > ret(lgth);
4784 for(int i=0;i<lgth;i++)
4785 _time_steps[i]->fillIteration(ret[i]);
4790 * This method has 3 inputs 'iteration' 'order' 'mname'. 'mname' can be null if the user is the general case where there is only one meshName lying on 'this'
4791 * This method returns two things.
4792 * - The absolute dimension of 'this' in first parameter.
4793 * - The available ext levels relative to the absolute dimension returned in first parameter. These relative levels are relative
4794 * to the first output parameter. The values in 'levs' will be returned in decreasing order.
4796 * This method is designed for MEDFileFieldMultiTS instances that have a discritization ON_CELLS, ON_GAUSS_NE and ON_GAUSS.
4797 * Only these 3 discretizations will be taken into account here.
4799 * If 'this' is empty this method will throw an INTERP_KERNEL::Exception.
4800 * If there is \b only node fields defined in 'this' -1 is returned and 'levs' output parameter will be empty. In this
4801 * case the caller has to know the underlying mesh it refers to. By defaut it is the level 0 of the corresponding mesh.
4803 * This method is usefull to make the link between meshDimension of the underlying mesh in 'this' and the levels on 'this'.
4804 * It is possible (even if it is not common) that the highest level in 'this' were not equal to the meshDimension of the underlying mesh in 'this'.
4806 * Let's consider the typical following case :
4807 * - a mesh 'm1' has a meshDimension 3 and has the following non empty levels
4808 * [0,-1,-2] for example 'm1' lies on TETRA4, HEXA8 TRI3 and SEG2
4809 * - 'f1' lies on 'm1' and is defined on 3D and 1D cells for example
4811 * - 'f2' lies on 'm1' too and is defined on 2D and 1D cells for example TRI3 and SEG2
4813 * In this case f1->getNonEmptyLevelsExt will return (3,[0,-2]) and f2->getNonEmptyLevelsExt will return (2,[0,-1])
4815 * To retrieve the highest level of f1 it should be done, f1->getFieldAtLevel(ON_CELLS,3-3+0);//absDim-meshDim+relativeLev
4816 * To retrieve the lowest level of f1 it should be done, f1->getFieldAtLevel(ON_CELLS,3-3+(-2));//absDim-meshDim+relativeLev
4817 * To retrieve the highest level of f2 it should be done, f1->getFieldAtLevel(ON_CELLS,2-3+0);//absDim-meshDim+relativeLev
4818 * To retrieve the lowest level of f2 it should be done, f1->getFieldAtLevel(ON_CELLS,2-3+(-1));//absDim-meshDim+relativeLev
4820 int MEDFileFieldMultiTSWithoutSDA::getNonEmptyLevels(int iteration, int order, const char *mname, std::vector<int>& levs) const throw(INTERP_KERNEL::Exception)
4822 return getTimeStepEntry(iteration,order).getNonEmptyLevels(mname,levs);
4825 std::vector< std::vector<TypeOfField> > MEDFileFieldMultiTSWithoutSDA::getTypesOfFieldAvailable() const throw(INTERP_KERNEL::Exception)
4827 int lgth=_time_steps.size();
4828 std::vector< std::vector<TypeOfField> > ret(lgth);
4829 for(int i=0;i<lgth;i++)
4830 _time_steps[i]->fillTypesOfFieldAvailable(ret[i]);
4835 * entry point for users that want to iterate into MEDFile DataStructure without any overhead.
4837 std::vector< std::vector< std::pair<int,int> > > MEDFileFieldMultiTSWithoutSDA::getFieldSplitedByType(int iteration, int order, const char *mname, std::vector<INTERP_KERNEL::NormalizedCellType>& types, std::vector< std::vector<TypeOfField> >& typesF, std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> >& locs) const throw(INTERP_KERNEL::Exception)
4839 return getTimeStepEntry(iteration,order).getFieldSplitedByType(mname,types,typesF,pfls,locs);
4843 * entry point for users that want to iterate into MEDFile DataStructure with a reduced overhead because output arrays are extracted (created) specially
4844 * for the call of this method. That's why the DataArrayDouble instance in returned vector of vector should be dealed by the caller.
4846 std::vector< std::vector<DataArrayDouble *> > MEDFileFieldMultiTSWithoutSDA::getFieldSplitedByType2(int iteration, int order, const char *mname, std::vector<INTERP_KERNEL::NormalizedCellType>& types, std::vector< std::vector<TypeOfField> >& typesF, std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> >& locs) const throw(INTERP_KERNEL::Exception)
4848 return getTimeStepEntry(iteration,order).getFieldSplitedByType2(mname,types,typesF,pfls,locs);
4851 const MEDFileField1TSWithoutSDA& MEDFileFieldMultiTSWithoutSDA::getTimeStepEntry(int iteration, int order) const throw(INTERP_KERNEL::Exception)
4853 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
4854 if((*it)->isDealingTS(iteration,order))
4856 std::ostringstream oss; oss << "MEDFileFieldMultiTS::getTimeStepEntry : Muli timestep field on time (" << iteration << "," << order << ") does not exist ! Available (iteration,order) are :\n";
4857 std::vector< std::pair<int,int> > vp=getIterations();
4858 for(std::vector< std::pair<int,int> >::const_iterator it2=vp.begin();it2!=vp.end();it2++)
4859 oss << "(" << (*it2).first << "," << (*it2).second << ") ";
4860 throw INTERP_KERNEL::Exception(oss.str().c_str());
4863 MEDFileField1TSWithoutSDA& MEDFileFieldMultiTSWithoutSDA::getTimeStepEntry(int iteration, int order) throw(INTERP_KERNEL::Exception)
4865 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
4866 if((*it)->isDealingTS(iteration,order))
4868 std::ostringstream oss; oss << "MEDFileFieldMultiTS::getTimeStepEntry : Muli timestep field on time (" << iteration << "," << order << ") does not exist ! Available (iteration,order) are :\n";
4869 std::vector< std::pair<int,int> > vp=getIterations();
4870 for(std::vector< std::pair<int,int> >::const_iterator it2=vp.begin();it2!=vp.end();it2++)
4871 oss << "(" << (*it2).first << "," << (*it2).second << ") ";
4872 throw INTERP_KERNEL::Exception(oss.str().c_str());
4875 const MEDFileField1TSWithoutSDA *MEDFileFieldMultiTSWithoutSDA::getTimeStepAtPos2(int pos) const throw(INTERP_KERNEL::Exception)
4877 if(pos<0 || pos>=(int)_time_steps.size())
4879 std::ostringstream oss; oss << "MEDFileFieldMultiTSWithoutSDA::getTimeStepAtPos2 : request for pos #" << pos << " whereas should be in [0," << _time_steps.size() << ") !";
4880 throw INTERP_KERNEL::Exception(oss.str().c_str());
4882 const MEDFileField1TSWithoutSDA *item=_time_steps[pos];
4885 std::ostringstream oss; oss << "MEDFileFieldMultiTSWithoutSDA::getTimeStepAtPos2 : request for pos #" << pos << ", this pos id exists but the underlying Field1TS is null !";
4886 oss << "\nTry to use following method eraseEmptyTS !";
4887 throw INTERP_KERNEL::Exception(oss.str().c_str());
4892 MEDFileField1TSWithoutSDA *MEDFileFieldMultiTSWithoutSDA::getTimeStepAtPos2(int pos) throw(INTERP_KERNEL::Exception)
4894 if(pos<0 || pos>=(int)_time_steps.size())
4896 std::ostringstream oss; oss << "MEDFileFieldMultiTSWithoutSDA::getTimeStepAtPos2 : request for pos #" << pos << " whereas should be in [0," << _time_steps.size() << ") !";
4897 throw INTERP_KERNEL::Exception(oss.str().c_str());
4899 MEDFileField1TSWithoutSDA *item=_time_steps[pos];
4902 std::ostringstream oss; oss << "MEDFileFieldMultiTSWithoutSDA::getTimeStepAtPos2 : request for pos #" << pos << ", this pos id exists but the underlying Field1TS is null !";
4903 oss << "\nTry to use following method eraseEmptyTS !";
4904 throw INTERP_KERNEL::Exception(oss.str().c_str());
4909 std::vector<std::string> MEDFileFieldMultiTSWithoutSDA::getPflsReallyUsed2() const
4911 std::vector<std::string> ret;
4912 std::set<std::string> ret2;
4913 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileField1TSWithoutSDA > >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
4915 std::vector<std::string> tmp=(*it)->getPflsReallyUsed2();
4916 for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
4917 if(ret2.find(*it2)==ret2.end())
4919 ret.push_back(*it2);
4926 std::vector<std::string> MEDFileFieldMultiTSWithoutSDA::getLocsReallyUsed2() const
4928 std::vector<std::string> ret;
4929 std::set<std::string> ret2;
4930 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileField1TSWithoutSDA > >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
4932 std::vector<std::string> tmp=(*it)->getLocsReallyUsed2();
4933 for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
4934 if(ret2.find(*it2)==ret2.end())
4936 ret.push_back(*it2);
4943 std::vector<std::string> MEDFileFieldMultiTSWithoutSDA::getPflsReallyUsedMulti2() const
4945 std::vector<std::string> ret;
4946 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileField1TSWithoutSDA > >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
4948 std::vector<std::string> tmp=(*it)->getPflsReallyUsedMulti2();
4949 ret.insert(ret.end(),tmp.begin(),tmp.end());
4954 std::vector<std::string> MEDFileFieldMultiTSWithoutSDA::getLocsReallyUsedMulti2() const
4956 std::vector<std::string> ret;
4957 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileField1TSWithoutSDA > >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
4959 std::vector<std::string> tmp=(*it)->getLocsReallyUsedMulti2();
4960 ret.insert(ret.end(),tmp.begin(),tmp.end());
4965 void MEDFileFieldMultiTSWithoutSDA::changePflsRefsNamesGen2(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
4967 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileField1TSWithoutSDA > >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
4968 (*it)->changePflsRefsNamesGen2(mapOfModif);
4971 void MEDFileFieldMultiTSWithoutSDA::changeLocsRefsNamesGen2(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
4973 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileField1TSWithoutSDA > >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
4974 (*it)->changeLocsRefsNamesGen2(mapOfModif);
4977 MEDFileFieldMultiTS *MEDFileFieldMultiTS::New()
4979 return new MEDFileFieldMultiTS;
4982 MEDFileFieldMultiTS *MEDFileFieldMultiTS::New(const char *fileName) throw(INTERP_KERNEL::Exception)
4984 return new MEDFileFieldMultiTS(fileName);
4987 MEDFileFieldMultiTS *MEDFileFieldMultiTS::New(const char *fileName, const char *fieldName) throw(INTERP_KERNEL::Exception)
4989 return new MEDFileFieldMultiTS(fileName,fieldName);
4992 MEDFileFieldMultiTS *MEDFileFieldMultiTS::New(const MEDFileFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent)
4994 return new MEDFileFieldMultiTS(other,shallowCopyOfContent);
4997 std::size_t MEDFileFieldMultiTS::getHeapMemorySize() const
5000 if((const MEDFileFieldMultiTSWithoutSDA*)_content)
5001 ret+=_content->getHeapMemorySize();
5002 return ret+MEDFileFieldGlobsReal::getHeapMemorySize();
5005 MEDFileFieldMultiTS *MEDFileFieldMultiTS::deepCpy() const throw(INTERP_KERNEL::Exception)
5007 MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTS> ret=new MEDFileFieldMultiTS(*this);
5008 if((const MEDFileFieldMultiTSWithoutSDA *)_content)
5009 ret->_content=_content->deepCpy();
5010 ret->deepCpyGlobs(*this);
5015 * \return a new allocated object that the caller should deal with.
5017 MEDFileField1TS *MEDFileFieldMultiTS::getTimeStepAtPos(int pos) const throw(INTERP_KERNEL::Exception)
5019 const MEDFileField1TSWithoutSDA *item=_content->getTimeStepAtPos2(pos);
5020 MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=MEDFileField1TS::New(*item,false);
5021 ret->shallowCpyGlobs(*this);
5026 * \return a new allocated object that the caller should deal with.
5028 MEDFileField1TS *MEDFileFieldMultiTS::getTimeStep(int iteration, int order) const throw(INTERP_KERNEL::Exception)
5030 int pos=getPosOfTimeStep(iteration,order);
5031 return getTimeStepAtPos(pos);
5035 * \return a new allocated object that the caller should deal with.
5037 MEDFileField1TS *MEDFileFieldMultiTS::getTimeStepGivenTime(double time, double eps) const throw(INTERP_KERNEL::Exception)
5039 int pos=getPosGivenTime(time,eps);
5040 return getTimeStepAtPos(pos);
5043 MEDFileFieldMultiTSIterator *MEDFileFieldMultiTS::iterator() throw(INTERP_KERNEL::Exception)
5045 return new MEDFileFieldMultiTSIterator(this);
5048 std::string MEDFileFieldMultiTS::simpleRepr() const
5050 std::ostringstream oss;
5051 _content->simpleRepr(0,oss,-1);
5052 MEDFileFieldGlobsReal::simpleRepr(oss);
5056 void MEDFileFieldMultiTS::writeLL(med_idt fid) const throw(INTERP_KERNEL::Exception)
5058 writeGlobals(fid,*this);
5059 _content->writeLL(fid,*this);
5062 void MEDFileFieldMultiTS::write(const char *fileName, int mode) const throw(INTERP_KERNEL::Exception)
5064 med_access_mode medmod=MEDFileUtilities::TraduceWriteMode(mode);
5065 MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,medmod);
5070 * Performs the job than MEDFileField1TS::getFieldAtLevel except that (iteration,order) couple should be specified !
5071 * If such couple does not exist an exception is thrown.
5073 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldAtLevel(TypeOfField type, int iteration, int order, int meshDimRelToMax, int renumPol) const throw(INTERP_KERNEL::Exception)
5075 const MEDFileField1TSWithoutSDA& myF1TS=_content->getTimeStepEntry(iteration,order);
5076 return myF1TS.getFieldAtLevel(type,meshDimRelToMax,0,renumPol,this);
5079 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldAtTopLevel(TypeOfField type, int iteration, int order, int renumPol) const throw(INTERP_KERNEL::Exception)
5081 const MEDFileField1TSWithoutSDA& myF1TS=_content->getTimeStepEntry(iteration,order);
5082 return myF1TS.getFieldAtTopLevel(type,0,renumPol,this);
5086 * Performs the job than MEDFileField1TS::getFieldOnMeshAtLevel except that (iteration,order) couple should be specified !
5087 * If such couple does not exist an exception is thrown.
5089 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldOnMeshAtLevel(TypeOfField type, int iteration, int order, int meshDimRelToMax, const MEDFileMesh *mesh, int renumPol) const throw(INTERP_KERNEL::Exception)
5091 const MEDFileField1TSWithoutSDA& myF1TS=_content->getTimeStepEntry(iteration,order);
5092 return myF1TS.getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,this,mesh);
5096 * Performs the job than MEDFileField1TS::getFieldOnMeshAtLevel except that (iteration,order) couple should be specified !
5097 * If such couple does not exist an exception is thrown.
5099 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldOnMeshAtLevel(TypeOfField type, int iteration, int order, const MEDCouplingMesh *mesh, int renumPol) const throw(INTERP_KERNEL::Exception)
5101 const MEDFileField1TSWithoutSDA& myF1TS=_content->getTimeStepEntry(iteration,order);
5102 return myF1TS.getFieldOnMeshAtLevel(type,renumPol,this,mesh,0,0);
5106 * This method has a close behaviour than MEDFileFieldMultiTS::getFieldAtLevel.
5107 * This method is called 'old' because the user should give the mesh name he wants to use for it's field.
5108 * This method is useful for MED2 file format when field on different mesh was autorized.
5110 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldAtLevelOld(TypeOfField type, const char *mname, int iteration, int order, int meshDimRelToMax, int renumPol) const throw(INTERP_KERNEL::Exception)
5112 const MEDFileField1TSWithoutSDA& myF1TS=_content->getTimeStepEntry(iteration,order);
5113 return myF1TS.getFieldAtLevel(type,meshDimRelToMax,mname,renumPol,this);
5116 DataArrayDouble *MEDFileFieldMultiTS::getFieldWithProfile(TypeOfField type, int iteration, int order, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt *&pfl) const throw(INTERP_KERNEL::Exception)
5118 const MEDFileField1TSWithoutSDA& myF1TS=_content->getTimeStepEntry(iteration,order);
5119 return myF1TS.getFieldWithProfile(type,meshDimRelToMax,mesh,pfl,this);
5122 void MEDFileFieldMultiTS::appendFieldNoProfileSBT(const MEDCouplingFieldDouble *field) throw(INTERP_KERNEL::Exception)
5124 _content->appendFieldNoProfileSBT(field,*this);
5127 void MEDFileFieldMultiTS::appendFieldProfile(const MEDCouplingFieldDouble *field, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile) throw(INTERP_KERNEL::Exception)
5129 _content->appendFieldProfile(field,mesh,meshDimRelToMax,profile,*this);
5132 MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTSWithoutSDA> MEDFileFieldMultiTS::getContent()
5137 MEDFileFieldMultiTS::MEDFileFieldMultiTS():_content(new MEDFileFieldMultiTSWithoutSDA)
5143 MEDFileFieldMultiTS::MEDFileFieldMultiTS(const char *fileName) throw(INTERP_KERNEL::Exception)
5144 try:MEDFileFieldGlobsReal(fileName)
5146 MEDFileUtilities::CheckFileForRead(fileName);
5147 MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
5148 int nbFields=MEDnField(fid);
5151 std::ostringstream oss; oss << "MEDFileFieldMultiTS(const char *fileName) constructor : no fields in file \"" << fileName << "\" !";
5152 throw INTERP_KERNEL::Exception(oss.str().c_str());
5154 _content=new MEDFileFieldMultiTSWithoutSDA(fid,0);
5158 catch(INTERP_KERNEL::Exception& e)
5163 MEDFileFieldMultiTS::MEDFileFieldMultiTS(const char *fileName, const char *fieldName) throw(INTERP_KERNEL::Exception)
5164 try:MEDFileFieldGlobsReal(fileName)
5166 MEDFileUtilities::CheckFileForRead(fileName);
5167 MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
5168 int nbFields=MEDnField(fid);
5169 med_field_type typcha;
5171 std::vector<std::string> fns(nbFields);
5172 for(int i=0;i<nbFields && !found;i++)
5174 int ncomp=MEDfieldnComponent(fid,i+1);
5175 INTERP_KERNEL::AutoPtr<char> comp=MEDLoaderBase::buildEmptyString(ncomp*MED_SNAME_SIZE);
5176 INTERP_KERNEL::AutoPtr<char> unit=MEDLoaderBase::buildEmptyString(ncomp*MED_SNAME_SIZE);
5177 INTERP_KERNEL::AutoPtr<char> dtunit=MEDLoaderBase::buildEmptyString(MED_LNAME_SIZE);
5178 INTERP_KERNEL::AutoPtr<char> nomcha=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
5179 INTERP_KERNEL::AutoPtr<char> nomMaa=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
5182 MEDfieldInfo(fid,i+1,nomcha,nomMaa,&localMesh,&typcha,comp,unit,dtunit,&nbOfStep);
5183 std::string tmp(nomcha);
5185 found=(tmp==fieldName);
5187 _content=new MEDFileFieldMultiTSWithoutSDA(fid,i);
5191 std::ostringstream oss; oss << "No such field '" << fieldName << "' in file '" << fileName << "' ! Available fields are : ";
5192 std::copy(fns.begin(),fns.end(),std::ostream_iterator<std::string>(oss," "));
5193 throw INTERP_KERNEL::Exception(oss.str().c_str());
5198 catch(INTERP_KERNEL::Exception& e)
5203 MEDFileFieldMultiTS::MEDFileFieldMultiTS(const MEDFileFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent)
5205 if(!shallowCopyOfContent)
5207 const MEDFileFieldMultiTSWithoutSDA *otherPtr(&other);
5208 otherPtr->incrRef();
5209 _content=const_cast<MEDFileFieldMultiTSWithoutSDA *>(otherPtr);
5213 _content=new MEDFileFieldMultiTSWithoutSDA(other);
5217 std::vector<std::string> MEDFileFieldMultiTS::getPflsReallyUsed() const
5219 return _content->getPflsReallyUsed2();
5222 std::vector<std::string> MEDFileFieldMultiTS::getLocsReallyUsed() const
5224 return _content->getLocsReallyUsed2();
5227 std::vector<std::string> MEDFileFieldMultiTS::getPflsReallyUsedMulti() const
5229 return _content->getPflsReallyUsedMulti2();
5232 std::vector<std::string> MEDFileFieldMultiTS::getLocsReallyUsedMulti() const
5234 return _content->getLocsReallyUsedMulti2();
5237 void MEDFileFieldMultiTS::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
5239 _content->changePflsRefsNamesGen2(mapOfModif);
5242 void MEDFileFieldMultiTS::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
5244 _content->changeLocsRefsNamesGen2(mapOfModif);
5247 int MEDFileFieldMultiTS::getNumberOfTS() const
5249 return _content->getNumberOfTS();
5252 void MEDFileFieldMultiTS::eraseEmptyTS() throw(INTERP_KERNEL::Exception)
5254 _content->eraseEmptyTS();
5257 void MEDFileFieldMultiTS::eraseTimeStepIds(const int *startIds, const int *endIds) throw(INTERP_KERNEL::Exception)
5259 _content->eraseTimeStepIds(startIds,endIds);
5262 std::vector< std::pair<int,int> > MEDFileFieldMultiTS::getIterations() const
5264 return _content->getIterations();
5267 int MEDFileFieldMultiTS::getPosOfTimeStep(int iteration, int order) const throw(INTERP_KERNEL::Exception)
5269 return _content->getPosOfTimeStep(iteration,order);
5272 int MEDFileFieldMultiTS::getPosGivenTime(double time, double eps) const throw(INTERP_KERNEL::Exception)
5274 return _content->getPosGivenTime(time,eps);
5277 int MEDFileFieldMultiTS::getNonEmptyLevels(int iteration, int order, const char *mname, std::vector<int>& levs) const throw(INTERP_KERNEL::Exception)
5279 return _content->getNonEmptyLevels(iteration,order,mname,levs);
5282 std::vector< std::vector<TypeOfField> > MEDFileFieldMultiTS::getTypesOfFieldAvailable() const throw(INTERP_KERNEL::Exception)
5284 return _content->getTypesOfFieldAvailable();
5287 std::vector< std::vector< std::pair<int,int> > > MEDFileFieldMultiTS::getFieldSplitedByType(int iteration, int order, const char *mname, std::vector<INTERP_KERNEL::NormalizedCellType>& types, std::vector< std::vector<TypeOfField> >& typesF, std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> >& locs) const throw(INTERP_KERNEL::Exception)
5289 return _content->getFieldSplitedByType(iteration,order,mname,types,typesF,pfls,locs);
5292 std::vector< std::vector<DataArrayDouble *> > MEDFileFieldMultiTS::getFieldSplitedByType2(int iteration, int order, const char *mname, std::vector<INTERP_KERNEL::NormalizedCellType>& types, std::vector< std::vector<TypeOfField> >& typesF, std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> >& locs) const throw(INTERP_KERNEL::Exception)
5294 return _content->getFieldSplitedByType2(iteration,order,mname,types,typesF,pfls,locs);
5297 std::string MEDFileFieldMultiTS::getName() const
5299 return _content->getName();
5302 void MEDFileFieldMultiTS::setName(const char *name)
5304 _content->setName(name);
5307 void MEDFileFieldMultiTS::simpleRepr(int bkOffset, std::ostream& oss, int fmtsId) const
5309 _content->simpleRepr(bkOffset,oss,fmtsId);
5312 std::vector< std::pair<int,int> > MEDFileFieldMultiTS::getTimeSteps(std::vector<double>& ret1) const throw(INTERP_KERNEL::Exception)
5314 return _content->getTimeSteps(ret1);
5317 std::string MEDFileFieldMultiTS::getMeshName() const throw(INTERP_KERNEL::Exception)
5319 return _content->getMeshName();
5322 void MEDFileFieldMultiTS::setMeshName(const char *newMeshName) throw(INTERP_KERNEL::Exception)
5324 _content->setMeshName(newMeshName);
5327 bool MEDFileFieldMultiTS::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab) throw(INTERP_KERNEL::Exception)
5329 return _content->changeMeshNames(modifTab);
5332 const std::vector<std::string>& MEDFileFieldMultiTS::getInfo() const throw(INTERP_KERNEL::Exception)
5334 return _content->getInfo();
5337 DataArrayDouble *MEDFileFieldMultiTS::getUndergroundDataArray(int iteration, int order) const throw(INTERP_KERNEL::Exception)
5339 return _content->getUndergroundDataArray(iteration,order);
5342 DataArrayDouble *MEDFileFieldMultiTS::getUndergroundDataArrayExt(int iteration, int order, std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const throw(INTERP_KERNEL::Exception)
5344 return _content->getUndergroundDataArrayExt(iteration,order,entries);
5347 MEDFileFieldMultiTSIterator::MEDFileFieldMultiTSIterator(MEDFileFieldMultiTS *fmts):_fmts(fmts),_iter_id(0),_nb_iter(0)
5352 _nb_iter=fmts->getNumberOfTS();
5356 MEDFileFieldMultiTSIterator::~MEDFileFieldMultiTSIterator()
5360 MEDFileField1TS *MEDFileFieldMultiTSIterator::nextt()
5362 if(_iter_id<_nb_iter)
5364 MEDFileFieldMultiTS *fmts(_fmts);
5366 return fmts->getTimeStepAtPos(_iter_id++);
5374 MEDFileFields *MEDFileFields::New()
5376 return new MEDFileFields;
5379 MEDFileFields *MEDFileFields::New(const char *fileName) throw(INTERP_KERNEL::Exception)
5381 return new MEDFileFields(fileName);
5384 std::size_t MEDFileFields::getHeapMemorySize() const
5386 std::size_t ret=_fields.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTSWithoutSDA>);
5387 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
5388 if((const MEDFileFieldMultiTSWithoutSDA *)*it)
5389 ret+=(*it)->getHeapMemorySize();
5390 return ret+MEDFileFieldGlobsReal::getHeapMemorySize();
5393 MEDFileFields *MEDFileFields::deepCpy() const throw(INTERP_KERNEL::Exception)
5395 MEDCouplingAutoRefCountObjectPtr<MEDFileFields> ret=new MEDFileFields(*this);
5397 for( std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
5399 if((const MEDFileFieldMultiTSWithoutSDA*)*it)
5400 ret->_fields[i]=(*it)->deepCpy();
5402 ret->deepCpyGlobs(*this);
5406 int MEDFileFields::getNumberOfFields() const
5408 return _fields.size();
5411 std::vector<std::string> MEDFileFields::getFieldsNames() const throw(INTERP_KERNEL::Exception)
5413 std::vector<std::string> ret(_fields.size());
5415 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
5417 const MEDFileFieldMultiTSWithoutSDA *f=(*it);
5420 ret[i]=f->getName();
5424 std::ostringstream oss; oss << "MEDFileFields::getFieldsNames : At rank #" << i << " field is not defined !";
5425 throw INTERP_KERNEL::Exception(oss.str().c_str());
5431 std::vector<std::string> MEDFileFields::getMeshesNames() const throw(INTERP_KERNEL::Exception)
5433 std::vector<std::string> ret;
5434 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
5436 const MEDFileFieldMultiTSWithoutSDA *cur(*it);
5438 ret.push_back(cur->getMeshName());
5443 std::string MEDFileFields::simpleRepr() const
5445 std::ostringstream oss;
5446 oss << "(*****************)\n(* MEDFileFields *)\n(*****************)\n\n";
5451 void MEDFileFields::simpleRepr(int bkOffset, std::ostream& oss) const
5453 int nbOfFields=getNumberOfFields();
5454 std::string startLine(bkOffset,' ');
5455 oss << startLine << "There are " << nbOfFields << " fields in this :" << std::endl;
5457 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
5459 const MEDFileFieldMultiTSWithoutSDA *cur=(*it);
5462 oss << startLine << " - # "<< i << " has the following name : \"" << cur->getName() << "\"." << std::endl;
5466 oss << startLine << " - not defined !" << std::endl;
5470 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
5472 const MEDFileFieldMultiTSWithoutSDA *cur=(*it);
5473 std::string chapter(17,'0'+i);
5474 oss << startLine << chapter << std::endl;
5477 cur->simpleRepr(bkOffset+2,oss,i);
5481 oss << startLine << " - not defined !" << std::endl;
5483 oss << startLine << chapter << std::endl;
5485 MEDFileFieldGlobsReal::simpleRepr(oss);
5488 MEDFileFields::MEDFileFields()
5492 MEDFileFields::MEDFileFields(const char *fileName) throw(INTERP_KERNEL::Exception)
5493 try:MEDFileFieldGlobsReal(fileName)
5495 MEDFileUtilities::CheckFileForRead(fileName);
5496 MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
5497 int nbFields=MEDnField(fid);
5498 _fields.resize(nbFields);
5499 med_field_type typcha;
5500 for(int i=0;i<nbFields;i++)
5502 int ncomp=MEDfieldnComponent(fid,i+1);
5503 INTERP_KERNEL::AutoPtr<char> comp=MEDLoaderBase::buildEmptyString(ncomp*MED_SNAME_SIZE);
5504 INTERP_KERNEL::AutoPtr<char> unit=MEDLoaderBase::buildEmptyString(ncomp*MED_SNAME_SIZE);
5505 INTERP_KERNEL::AutoPtr<char> dtunit=MEDLoaderBase::buildEmptyString(MED_LNAME_SIZE);
5506 INTERP_KERNEL::AutoPtr<char> nomcha=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
5507 INTERP_KERNEL::AutoPtr<char> nomMaa=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
5510 MEDfieldInfo(fid,i+1,nomcha,nomMaa,&localMesh,&typcha,comp,unit,dtunit,&nbOfStep);
5511 int ft=MEDFileUtilities::TraduceFieldType(typcha);
5512 std::vector<std::string> infos(ncomp);
5513 for(int j=0;j<ncomp;j++)
5514 infos[j]=MEDLoaderBase::buildUnionUnit((char *)comp+j*MED_SNAME_SIZE,MED_SNAME_SIZE,(char *)unit+j*MED_SNAME_SIZE,MED_SNAME_SIZE);
5515 _fields[i]=MEDFileFieldMultiTSWithoutSDA::New(fid,nomcha,i+1,ft,infos,nbOfStep);
5517 loadAllGlobals(fid);
5519 catch(INTERP_KERNEL::Exception& e)
5524 void MEDFileFields::writeLL(med_idt fid) const throw(INTERP_KERNEL::Exception)
5527 writeGlobals(fid,*this);
5528 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
5530 const MEDFileFieldMultiTSWithoutSDA *elt=*it;
5533 std::ostringstream oss; oss << "MEDFileFields::write : at rank #" << i << "/" << _fields.size() << " field is empty !";
5534 throw INTERP_KERNEL::Exception(oss.str().c_str());
5536 elt->writeLL(fid,*this);
5540 void MEDFileFields::write(const char *fileName, int mode) const throw(INTERP_KERNEL::Exception)
5542 med_access_mode medmod=MEDFileUtilities::TraduceWriteMode(mode);
5543 MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,medmod);
5547 std::vector<std::string> MEDFileFields::getPflsReallyUsed() const
5549 std::vector<std::string> ret;
5550 std::set<std::string> ret2;
5551 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldMultiTSWithoutSDA > >::const_iterator it=_fields.begin();it!=_fields.end();it++)
5553 std::vector<std::string> tmp=(*it)->getPflsReallyUsed2();
5554 for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
5555 if(ret2.find(*it2)==ret2.end())
5557 ret.push_back(*it2);
5564 std::vector<std::string> MEDFileFields::getLocsReallyUsed() const
5566 std::vector<std::string> ret;
5567 std::set<std::string> ret2;
5568 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldMultiTSWithoutSDA > >::const_iterator it=_fields.begin();it!=_fields.end();it++)
5570 std::vector<std::string> tmp=(*it)->getLocsReallyUsed2();
5571 for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
5572 if(ret2.find(*it2)==ret2.end())
5574 ret.push_back(*it2);
5581 std::vector<std::string> MEDFileFields::getPflsReallyUsedMulti() const
5583 std::vector<std::string> ret;
5584 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldMultiTSWithoutSDA > >::const_iterator it=_fields.begin();it!=_fields.end();it++)
5586 std::vector<std::string> tmp=(*it)->getPflsReallyUsedMulti2();
5587 ret.insert(ret.end(),tmp.begin(),tmp.end());
5592 std::vector<std::string> MEDFileFields::getLocsReallyUsedMulti() const
5594 std::vector<std::string> ret;
5595 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldMultiTSWithoutSDA > >::const_iterator it=_fields.begin();it!=_fields.end();it++)
5597 std::vector<std::string> tmp=(*it)->getLocsReallyUsed2();
5598 ret.insert(ret.end(),tmp.begin(),tmp.end());
5603 void MEDFileFields::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
5605 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldMultiTSWithoutSDA > >::iterator it=_fields.begin();it!=_fields.end();it++)
5606 (*it)->changePflsRefsNamesGen2(mapOfModif);
5609 void MEDFileFields::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif) throw(INTERP_KERNEL::Exception)
5611 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldMultiTSWithoutSDA > >::iterator it=_fields.begin();it!=_fields.end();it++)
5612 (*it)->changeLocsRefsNamesGen2(mapOfModif);
5615 void MEDFileFields::resize(int newSize) throw(INTERP_KERNEL::Exception)
5617 _fields.resize(newSize);
5620 void MEDFileFields::pushField(MEDFileFieldMultiTS *field) throw(INTERP_KERNEL::Exception)
5623 throw INTERP_KERNEL::Exception("MEDFileFields::pushMesh : invalid input pointer ! should be different from 0 !");
5624 _fields.push_back(field->getContent());
5625 appendGlobs(*field,1e-12);
5628 void MEDFileFields::setFieldAtPos(int i, MEDFileFieldMultiTS *field) throw(INTERP_KERNEL::Exception)
5631 throw INTERP_KERNEL::Exception("MEDFileFields::setFieldAtPos : invalid input pointer ! should be different from 0 !");
5632 if(i>=(int)_fields.size())
5633 _fields.resize(i+1);
5634 _fields[i]=field->getContent();
5635 appendGlobs(*field,1e-12);
5638 void MEDFileFields::destroyFieldAtPos(int i) throw(INTERP_KERNEL::Exception)
5640 if(i<0 || i>=(int)_fields.size())
5642 std::ostringstream oss; oss << "MEDFileFields::destroyMeshAtPos : Invalid given id in input (" << i << ") should be in [0," << _fields.size() << ") !";
5643 throw INTERP_KERNEL::Exception(oss.str().c_str());
5645 _fields.erase(_fields.begin()+i);
5648 bool MEDFileFields::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab) throw(INTERP_KERNEL::Exception)
5651 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
5653 MEDFileFieldMultiTSWithoutSDA *cur(*it);
5655 ret=cur->changeMeshNames(modifTab) || ret;
5661 * \param [in] meshName the name of the mesh that will be renumbered.
5662 * \param [in] oldCode is of format returned by MEDCouplingUMesh::getDistributionOfTypes. And for each *i* oldCode[3*i+2] gives the position (MEDFileUMesh::PutInThirdComponentOfCodeOffset).
5663 * This code corresponds to the distribution of types in the corresponding mesh.
5664 * \param [in] newCode idem to param \a oldCode except that here the new distribution is given.
5665 * \param [in] renumO2N the old to new renumber array.
5666 * \return If true a renumbering has been performed. The structure in \a this has been modified. If false, nothing has been done: it is typically the case if \a meshName is not refered by any
5669 bool MEDFileFields::renumberEntitiesLyingOnMesh(const char *meshName, const std::vector<int>& oldCode, const std::vector<int>& newCode, const DataArrayInt *renumO2N) throw(INTERP_KERNEL::Exception)
5672 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
5674 MEDFileFieldMultiTSWithoutSDA *fmts(*it);
5677 ret=fmts->renumberEntitiesLyingOnMesh(meshName,oldCode,newCode,renumO2N,*this) || ret;
5683 MEDFileFieldMultiTS *MEDFileFields::getFieldAtPos(int i) const throw(INTERP_KERNEL::Exception)
5685 if(i<0 || i>=(int)_fields.size())
5687 std::ostringstream oss; oss << "MEDFileFields::getFieldAtPos : Invalid given id in input (" << i << ") should be in [0," << _fields.size() << ") !";
5688 throw INTERP_KERNEL::Exception(oss.str().c_str());
5690 const MEDFileFieldMultiTSWithoutSDA *fmts=_fields[i];
5691 MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTS> ret=MEDFileFieldMultiTS::New(*fmts,false);
5692 ret->shallowCpyGlobs(*this);
5696 MEDFileFieldMultiTS *MEDFileFields::getFieldWithName(const char *fieldName) const throw(INTERP_KERNEL::Exception)
5698 return getFieldAtPos(getPosFromFieldName(fieldName));
5701 MEDFileFieldsIterator *MEDFileFields::iterator() throw(INTERP_KERNEL::Exception)
5703 return new MEDFileFieldsIterator(this);
5706 int MEDFileFields::getPosFromFieldName(const char *fieldName) const throw(INTERP_KERNEL::Exception)
5708 std::string tmp(fieldName);
5709 std::vector<std::string> poss;
5710 for(std::size_t i=0;i<_fields.size();i++)
5712 const MEDFileFieldMultiTSWithoutSDA *f=_fields[i];
5715 std::string fname(f->getName());
5719 poss.push_back(fname);
5722 std::ostringstream oss; oss << "MEDFileFields::getPosFromFieldName : impossible to find field '" << tmp << "' in this ! Possibilities are : ";
5723 std::copy(poss.begin(),poss.end(),std::ostream_iterator<std::string>(oss,", "));
5725 throw INTERP_KERNEL::Exception(oss.str().c_str());
5728 MEDFileFieldsIterator::MEDFileFieldsIterator(MEDFileFields *fs):_fs(fs),_iter_id(0),_nb_iter(0)
5733 _nb_iter=fs->getNumberOfFields();
5737 MEDFileFieldsIterator::~MEDFileFieldsIterator()
5741 MEDFileFieldMultiTS *MEDFileFieldsIterator::nextt()
5743 if(_iter_id<_nb_iter)
5745 MEDFileFields *fs(_fs);
5747 return fs->getFieldAtPos(_iter_id++);