1 // Copyright (C) 2007-2019 CEA/DEN, EDF R&D
3 // This library is free software; you can redistribute it and/or
4 // modify it under the terms of the GNU Lesser General Public
5 // License as published by the Free Software Foundation; either
6 // version 2.1 of the License, or (at your option) any later version.
8 // This library is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 // Lesser General Public License for more details.
13 // You should have received a copy of the GNU Lesser General Public
14 // License along with this library; if not, write to the Free Software
15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
19 // Author : Anthony Geay (EDF R&D)
21 #include "MEDFileField.hxx"
22 #include "MEDFileMesh.hxx"
23 #include "MEDLoaderBase.hxx"
24 #include "MEDLoaderTraits.hxx"
25 #include "MEDFileSafeCaller.txx"
26 #include "MEDFileFieldOverView.hxx"
27 #include "MEDFileBlowStrEltUp.hxx"
28 #include "MEDFileFieldVisitor.hxx"
30 #include "MEDCouplingFieldDiscretization.hxx"
32 #include "InterpKernelAutoPtr.hxx"
33 #include "CellModel.hxx"
38 extern INTERP_KERNEL::NormalizedCellType typmai2[MED_N_CELL_FIXED_GEO];
39 extern med_geometry_type typmainoeud[1];
40 extern med_geometry_type typmai3[INTERP_KERNEL::NORM_MAXTYPE];
42 using namespace MEDCoupling;
46 MEDFileFields *MEDFileFields::New()
48 return new MEDFileFields;
51 MEDFileFields *MEDFileFields::New(const std::string& fileName, bool loadAll)
53 MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
54 return New(fid,loadAll);
57 MEDFileFields *MEDFileFields::NewAdv(const std::string& fileName, bool loadAll, const MEDFileEntities *entities)
59 MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
60 return NewAdv(fid,loadAll,entities);
63 MEDFileFields *MEDFileFields::NewAdv(med_idt fid, bool loadAll, const MEDFileEntities *entities)
65 return new MEDFileFields(fid,loadAll,0,entities);
68 MEDFileFields *MEDFileFields::NewWithDynGT(const std::string& fileName, const MEDFileStructureElements *se, bool loadAll)
70 MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
71 return NewWithDynGT(fid,se,loadAll);
74 MEDFileFields *MEDFileFields::NewWithDynGT(med_idt fid, const MEDFileStructureElements *se, bool loadAll)
77 throw INTERP_KERNEL::Exception("MEDFileFields::NewWithDynGT : null struct element pointer !");
78 INTERP_KERNEL::AutoCppPtr<MEDFileEntities> entities(MEDFileEntities::BuildFrom(*se));
79 return new MEDFileFields(fid,loadAll,0,entities);
82 MEDFileFields *MEDFileFields::New(med_idt fid, bool loadAll)
84 return new MEDFileFields(fid,loadAll,0,0);
87 MEDFileFields *MEDFileFields::LoadPartOf(const std::string& fileName, bool loadAll, const MEDFileMeshes *ms)
89 MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
90 return new MEDFileFields(fid,loadAll,ms,0);
93 MEDFileFields *MEDFileFields::LoadSpecificEntities(const std::string& fileName, const std::vector< std::pair<TypeOfField,INTERP_KERNEL::NormalizedCellType> >& entities, bool loadAll)
95 MEDFileUtilities::CheckFileForRead(fileName);
96 INTERP_KERNEL::AutoCppPtr<MEDFileEntities> ent(new MEDFileStaticEntities(entities));
97 MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
98 return new MEDFileFields(fid,loadAll,0,ent);
101 std::size_t MEDFileFields::getHeapMemorySizeWithoutChildren() const
103 std::size_t ret(MEDFileFieldGlobsReal::getHeapMemorySizeWithoutChildren());
104 ret+=_fields.capacity()*sizeof(MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA>);
108 std::vector<const BigMemoryObject *> MEDFileFields::getDirectChildrenWithNull() const
110 std::vector<const BigMemoryObject *> ret;
111 for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
112 ret.push_back((const MEDFileAnyTypeFieldMultiTSWithoutSDA *)*it);
116 MEDFileFields *MEDFileFields::deepCopy() const
118 MCAuto<MEDFileFields> ret(shallowCpy());
120 for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
122 if((const MEDFileAnyTypeFieldMultiTSWithoutSDA*)*it)
123 ret->_fields[i]=(*it)->deepCopy();
125 ret->deepCpyGlobs(*this);
129 MEDFileFields *MEDFileFields::shallowCpy() const
131 return new MEDFileFields(*this);
135 * This method scans for all fields in \a this which time steps ids are common. Time step are discriminated by the pair of integer (iteration,order) whatever
136 * the double time value. If all returned time steps are \b exactly those for all fields in \a this output parameter \a areThereSomeForgottenTS will be set to false.
137 * If \a areThereSomeForgottenTS is set to true, only the sorted intersection of time steps present for all fields in \a this will be returned.
139 * \param [out] areThereSomeForgottenTS - indicates to the caller if there is some time steps in \a this that are not present for all fields in \a this.
140 * \return the sorted list of time steps (specified with a pair of integer iteration first and order second) present for all fields in \a this.
142 * \sa MEDFileFields::partOfThisLyingOnSpecifiedTimeSteps, MEDFileFields::partOfThisNotLyingOnSpecifiedTimeSteps
144 std::vector< std::pair<int,int> > MEDFileFields::getCommonIterations(bool& areThereSomeForgottenTS) const
146 std::set< std::pair<int,int> > s;
148 areThereSomeForgottenTS=false;
149 for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
151 if(!(const MEDFileAnyTypeFieldMultiTSWithoutSDA*)*it)
153 std::vector< std::pair<int,int> > v=(*it)->getIterations();
154 std::set< std::pair<int,int> > s1; std::copy(v.begin(),v.end(),std::inserter(s1,s1.end()));
156 { s=s1; firstShot=false; }
159 std::set< std::pair<int,int> > s2; std::set_intersection(s.begin(),s.end(),s1.begin(),s1.end(),std::inserter(s2,s2.end()));
161 areThereSomeForgottenTS=true;
165 std::vector< std::pair<int,int> > ret;
166 std::copy(s.begin(),s.end(),std::back_insert_iterator< std::vector< std::pair<int,int> > >(ret));
170 int MEDFileFields::getNumberOfFields() const
172 return (int)_fields.size();
175 std::vector<std::string> MEDFileFields::getFieldsNames() const
177 std::vector<std::string> ret(_fields.size());
179 for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
181 const MEDFileAnyTypeFieldMultiTSWithoutSDA *f=(*it);
188 std::ostringstream oss; oss << "MEDFileFields::getFieldsNames : At rank #" << i << " field is not defined !";
189 throw INTERP_KERNEL::Exception(oss.str());
195 std::vector<std::string> MEDFileFields::getMeshesNames() const
197 std::vector<std::string> ret;
198 for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
200 const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur(*it);
202 ret.push_back(cur->getMeshName());
207 std::string MEDFileFields::simpleRepr() const
209 std::ostringstream oss;
210 oss << "(*****************)\n(* MEDFileFields *)\n(*****************)\n\n";
215 void MEDFileFields::simpleRepr(int bkOffset, std::ostream& oss) const
217 int nbOfFields(getNumberOfFields());
218 std::string startLine(bkOffset,' ');
219 oss << startLine << "There are " << nbOfFields << " fields in this :" << std::endl;
221 for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
223 const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur=(*it);
226 oss << startLine << " - # "<< i << " has the following name : \"" << cur->getName() << "\"." << std::endl;
230 oss << startLine << " - not defined !" << std::endl;
234 for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
236 const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur=(*it);
237 std::string chapter(17,'0'+i);
238 oss << startLine << chapter << std::endl;
241 cur->simpleRepr(bkOffset+2,oss,i);
245 oss << startLine << " - not defined !" << std::endl;
247 oss << startLine << chapter << std::endl;
249 simpleReprGlobs(oss);
252 MEDFileFields::MEDFileFields()
256 MEDFileFields::MEDFileFields(med_idt fid, bool loadAll, const MEDFileMeshes *ms, const MEDFileEntities *entities)
257 try:MEDFileFieldGlobsReal(fid)
259 med_int nbFields(MEDnField(fid));
260 _fields.resize(nbFields);
261 med_field_type typcha;
262 for(int i=0;i<nbFields;i++)
264 std::vector<std::string> infos;
265 std::string fieldName,dtunit,meshName;
266 int nbOfStep(MEDFileAnyTypeField1TS::LocateField2(fid,i,false,fieldName,typcha,infos,dtunit,meshName));
271 _fields[i]=MEDFileFieldMultiTSWithoutSDA::New(fid,fieldName,meshName,typcha,infos,nbOfStep,dtunit,loadAll,ms,entities);
276 _fields[i]=MEDFileIntFieldMultiTSWithoutSDA::New(fid,fieldName,meshName,typcha,infos,nbOfStep,dtunit,loadAll,ms,entities);
281 _fields[i]=MEDFileFloatFieldMultiTSWithoutSDA::New(fid,fieldName,meshName,typcha,infos,nbOfStep,dtunit,loadAll,ms,entities);
286 if(sizeof(med_int)==sizeof(int))
288 _fields[i]=MEDFileIntFieldMultiTSWithoutSDA::New(fid,fieldName,meshName,typcha,infos,nbOfStep,dtunit,loadAll,ms,entities);
294 std::ostringstream oss; oss << "constructor MEDFileFields(fileName) : file \'" << FileNameFromFID(fid) << "\' at pos #" << i << " field has name \'" << fieldName << "\' but the type of field is not in [MED_FLOAT64, MED_INT32, MED_FLOAT32] !";
295 throw INTERP_KERNEL::Exception(oss.str());
299 loadAllGlobals(fid,entities);
301 catch(INTERP_KERNEL::Exception& e)
306 void MEDFileFields::writeLL(med_idt fid) const
309 writeGlobals(fid,*this);
310 for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
312 const MEDFileAnyTypeFieldMultiTSWithoutSDA *elt=*it;
315 std::ostringstream oss; oss << "MEDFileFields::write : at rank #" << i << "/" << _fields.size() << " field is empty !";
316 throw INTERP_KERNEL::Exception(oss.str());
318 elt->writeLL(fid,*this);
323 * This method alloc the arrays and load potentially huge arrays contained in this field.
324 * This method should be called when a MEDFileAnyTypeFieldMultiTS::New constructor has been with false as the last parameter.
325 * This method can be also called to refresh or reinit values from a file.
327 * \throw If the fileName is not set or points to a non readable MED file.
329 void MEDFileFields::loadArrays()
331 if(getFileName().empty())
332 throw INTERP_KERNEL::Exception("MEDFileFields::loadArrays : the structure does not come from a file !");
333 MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(getFileName()));
334 for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
336 MEDFileAnyTypeFieldMultiTSWithoutSDA *elt(*it);
338 elt->loadBigArraysRecursively(fid,*elt);
343 * This method behaves as MEDFileFields::loadArrays does, the first call, if \a this was built using a file without loading big arrays.
344 * But once data loaded once, this method does nothing.
346 * \throw If the fileName is not set or points to a non readable MED file.
347 * \sa MEDFileFields::loadArrays, MEDFileFields::unloadArrays
349 void MEDFileFields::loadArraysIfNecessary()
351 if(!getFileName().empty())
353 MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(getFileName()));
354 for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
356 MEDFileAnyTypeFieldMultiTSWithoutSDA *elt(*it);
358 elt->loadBigArraysRecursivelyIfNecessary(fid,*elt);
364 * This method releases potentially big data arrays and so returns to the same heap memory than status loaded with 'loadAll' parameter set to false.
365 * \b WARNING, this method does release arrays even if \a this does not come from a load of a MED file.
366 * So this method can lead to a loss of data. If you want to unload arrays safely call MEDFileFields::unloadArraysWithoutDataLoss instead.
368 * \sa MEDFileFields::loadArrays, MEDFileFields::loadArraysIfNecessary, MEDFileFields::unloadArraysWithoutDataLoss
370 void MEDFileFields::unloadArrays()
372 for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
374 MEDFileAnyTypeFieldMultiTSWithoutSDA *elt(*it);
381 * This method potentially releases big data arrays if \a this is coming from a file. If \a this has been built from scratch this method will have no effect.
382 * This method is the symmetrical method of MEDFileFields::loadArraysIfNecessary.
383 * This method is useful to reduce \b safely amount of heap memory necessary for \a this by using MED file as database.
385 * \sa MEDFileFields::loadArraysIfNecessary
387 void MEDFileFields::unloadArraysWithoutDataLoss()
389 if(!getFileName().empty())
393 std::vector<std::string> MEDFileFields::getPflsReallyUsed() const
395 std::vector<std::string> ret;
396 std::set<std::string> ret2;
397 for(std::vector< MCAuto< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::const_iterator it=_fields.begin();it!=_fields.end();it++)
399 std::vector<std::string> tmp=(*it)->getPflsReallyUsed2();
400 for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
401 if(ret2.find(*it2)==ret2.end())
410 std::vector<std::string> MEDFileFields::getLocsReallyUsed() const
412 std::vector<std::string> ret;
413 std::set<std::string> ret2;
414 for(std::vector< MCAuto< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::const_iterator it=_fields.begin();it!=_fields.end();it++)
416 std::vector<std::string> tmp((*it)->getLocsReallyUsed2());
417 for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
418 if(ret2.find(*it2)==ret2.end())
427 std::vector<std::string> MEDFileFields::getPflsReallyUsedMulti() const
429 std::vector<std::string> ret;
430 for(std::vector< MCAuto< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::const_iterator it=_fields.begin();it!=_fields.end();it++)
432 std::vector<std::string> tmp((*it)->getPflsReallyUsedMulti2());
433 ret.insert(ret.end(),tmp.begin(),tmp.end());
438 std::vector<std::string> MEDFileFields::getLocsReallyUsedMulti() const
440 std::vector<std::string> ret;
441 for(std::vector< MCAuto< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::const_iterator it=_fields.begin();it!=_fields.end();it++)
443 std::vector<std::string> tmp((*it)->getLocsReallyUsed2());
444 ret.insert(ret.end(),tmp.begin(),tmp.end());
449 void MEDFileFields::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
451 for(std::vector< MCAuto< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::iterator it=_fields.begin();it!=_fields.end();it++)
452 (*it)->changePflsRefsNamesGen2(mapOfModif);
455 void MEDFileFields::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
457 for(std::vector< MCAuto< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::iterator it=_fields.begin();it!=_fields.end();it++)
458 (*it)->changeLocsRefsNamesGen2(mapOfModif);
461 void MEDFileFields::resize(int newSize)
463 _fields.resize(newSize);
466 void MEDFileFields::pushFields(const std::vector<MEDFileAnyTypeFieldMultiTS *>& fields)
468 for(std::vector<MEDFileAnyTypeFieldMultiTS *>::const_iterator it=fields.begin();it!=fields.end();it++)
472 void MEDFileFields::pushField(MEDFileAnyTypeFieldMultiTS *field)
475 throw INTERP_KERNEL::Exception("MEDFileFields::pushMesh : invalid input pointer ! should be different from 0 !");
476 _fields.push_back(field->getContent());
477 appendGlobs(*field,1e-12);
480 void MEDFileFields::setFieldAtPos(int i, MEDFileAnyTypeFieldMultiTS *field)
483 throw INTERP_KERNEL::Exception("MEDFileFields::setFieldAtPos : invalid input pointer ! should be different from 0 !");
484 if(i>=(int)_fields.size())
486 _fields[i]=field->getContent();
487 appendGlobs(*field,1e-12);
490 void MEDFileFields::destroyFieldAtPos(int i)
492 destroyFieldsAtPos(&i,&i+1);
495 void MEDFileFields::destroyFieldsAtPos(const int *startIds, const int *endIds)
497 std::vector<bool> b(_fields.size(),true);
498 for(const int *i=startIds;i!=endIds;i++)
500 if(*i<0 || *i>=(int)_fields.size())
502 std::ostringstream oss; oss << "MEDFileFields::destroyFieldsAtPos : Invalid given id in input (" << *i << ") should be in [0," << _fields.size() << ") !";
503 throw INTERP_KERNEL::Exception(oss.str());
507 std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> > fields(std::count(b.begin(),b.end(),true));
509 for(std::size_t i=0;i<_fields.size();i++)
511 fields[j++]=_fields[i];
515 void MEDFileFields::destroyFieldsAtPos2(int bg, int end, int step)
517 static const char msg[]="MEDFileFields::destroyFieldsAtPos2";
518 mcIdType nbOfEntriesToKill(DataArrayIdType::GetNumberOfItemGivenBESRelative(bg,end,step,msg));
519 std::vector<bool> b(_fields.size(),true);
521 for(int i=0;i<nbOfEntriesToKill;i++,k+=step)
523 if(k<0 || k>=(int)_fields.size())
525 std::ostringstream oss; oss << "MEDFileFields::destroyFieldsAtPos2 : Invalid given id in input (" << k << ") should be in [0," << _fields.size() << ") !";
526 throw INTERP_KERNEL::Exception(oss.str());
530 std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> > fields(std::count(b.begin(),b.end(),true));
532 for(std::size_t i=0;i<_fields.size();i++)
534 fields[j++]=_fields[i];
538 bool MEDFileFields::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab)
541 for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
543 MEDFileAnyTypeFieldMultiTSWithoutSDA *cur(*it);
545 ret=cur->changeMeshNames(modifTab) || ret;
551 * \param [in] meshName the name of the mesh that will be renumbered.
552 * \param [in] oldCode is of format returned by MEDCouplingUMesh::getDistributionOfTypes. And for each *i* oldCode[3*i+2] gives the position (MEDFileUMesh::PutInThirdComponentOfCodeOffset).
553 * This code corresponds to the distribution of types in the corresponding mesh.
554 * \param [in] newCode idem to param \a oldCode except that here the new distribution is given.
555 * \param [in] renumO2N the old to new renumber array.
556 * \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 referred by any
559 bool MEDFileFields::renumberEntitiesLyingOnMesh(const std::string& meshName, const std::vector<mcIdType>& oldCode, const std::vector<mcIdType>& newCode, const DataArrayIdType *renumO2N)
562 for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
564 MEDFileAnyTypeFieldMultiTSWithoutSDA *fmts(*it);
567 ret=fmts->renumberEntitiesLyingOnMesh(meshName,oldCode,newCode,renumO2N,*this) || ret;
574 * Return an extraction of \a this using \a extractDef map to specify the extraction.
575 * The keys of \a extractDef is level relative to max ext of \a mm mesh.
577 * \return A new object that the caller is responsible to deallocate.
579 MEDFileFields *MEDFileFields::extractPart(const std::map<int, MCAuto<DataArrayIdType> >& extractDef, MEDFileMesh *mm) const
582 throw INTERP_KERNEL::Exception("MEDFileFields::extractPart : input mesh is NULL !");
583 MCAuto<MEDFileFields> fsOut(MEDFileFields::New());
584 int nbFields(getNumberOfFields());
585 for(int i=0;i<nbFields;i++)
587 MCAuto<MEDFileAnyTypeFieldMultiTS> fmts(getFieldAtPos(i));
590 std::ostringstream oss; oss << "MEDFileFields::extractPart : at pos #" << i << " field is null !";
591 throw INTERP_KERNEL::Exception(oss.str());
593 MCAuto<MEDFileAnyTypeFieldMultiTS> fmtsOut(fmts->extractPart(extractDef,mm));
594 fsOut->pushField(fmtsOut);
599 void MEDFileFields::accept(MEDFileFieldVisitor& visitor) const
601 for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
602 if((*it).isNotNull())
604 visitor.newFieldEntry(*it);
605 (*it)->accept(visitor);
606 visitor.endFieldEntry(*it);
613 PFLData():_add_pts_in_pfl(0) { }
614 PFLData(const MCAuto<DataArrayIdType>& mat, const MCAuto<DataArrayIdType>& pfl, mcIdType nbOfNewPts):_matrix(mat),_pfl(pfl),_add_pts_in_pfl(nbOfNewPts) { }
615 std::string getPflName() const { if(_pfl.isNull()) { return std::string(); } else { return _pfl->getName(); } }
616 mcIdType getNbOfAddPtsInPfl() const { return _add_pts_in_pfl; }
617 MCAuto<DataArrayIdType> getProfile() const { return _pfl; }
618 MCAuto<DataArrayIdType> getMatrix() const { return _matrix; }
620 MCAuto<DataArrayIdType> _matrix;
621 MCAuto<DataArrayIdType> _pfl;
622 mcIdType _add_pts_in_pfl;
625 class MEDFileFieldLin2QuadVisitor : public MEDFileFieldVisitor
628 MEDFileFieldLin2QuadVisitor(const MEDFileUMesh *lin, const MEDFileUMesh *quad, const MEDFileFieldGlobsReal *linGlobs, MEDFileFields* outFs):_lin(lin),_quad(quad),_lin_globs(linGlobs),_out_fs(outFs),_gt(INTERP_KERNEL::NORM_ERROR),_1ts_update_requested(false) { }
629 void newFieldEntry(const MEDFileAnyTypeFieldMultiTSWithoutSDA *field) { if(field->getMeshName()!=_lin->getName()) return; _cur_fmts=MEDFileFieldMultiTS::New(); }
630 void endFieldEntry(const MEDFileAnyTypeFieldMultiTSWithoutSDA *field) { if(_cur_fmts.isNotNull()) { if(_cur_fmts->getNumberOfTS()>0) _out_fs->pushField(_cur_fmts); } }
632 void newTimeStepEntry(const MEDFileAnyTypeField1TSWithoutSDA *ts);
633 void endTimeStepEntry(const MEDFileAnyTypeField1TSWithoutSDA *ts);
635 void newMeshEntry(const MEDFileFieldPerMesh *fpm);
636 void endMeshEntry(const MEDFileFieldPerMesh *fpm) { }
638 void newPerMeshPerTypeEntry(const MEDFileFieldPerMeshPerTypeCommon *pmpt);
639 void endPerMeshPerTypeEntry(const MEDFileFieldPerMeshPerTypeCommon *pmpt) { }
641 void newPerMeshPerTypePerDisc(const MEDFileFieldPerMeshPerTypePerDisc *pmptpd);
643 void updateData(MEDFileFieldPerMeshPerTypePerDisc *pmtd, mcIdType deltaNbNodes);
645 const MEDFileUMesh *_lin;
646 const MEDFileUMesh *_quad;
647 const MEDFileFieldGlobsReal *_lin_globs;
648 MEDFileFields *_out_fs;
649 MCAuto<MEDFileFieldMultiTS> _cur_fmts;
650 MCAuto<MEDFileField1TS> _cur_f1ts;
651 INTERP_KERNEL::NormalizedCellType _gt;
652 // Info on 1TS modification
653 bool _1ts_update_requested;
654 // Cache of matrix to compute faster the values on newly created points
655 std::map< std::string, PFLData > _cache;
656 std::vector<std::string> _pfls_to_be_updated;
659 void MEDFileFieldLin2QuadVisitor::newPerMeshPerTypePerDisc(const MEDFileFieldPerMeshPerTypePerDisc *pmptpd)
661 if(_cur_f1ts.isNull())
663 if(pmptpd->getType()!=ON_NODES)
664 throw INTERP_KERNEL::Exception("Not managed yet for ON_CELLS ON_GAUSS_NE and ON_GAUSS_PT");
665 _1ts_update_requested=true;
666 MEDFileAnyTypeField1TSWithoutSDA *ct(_cur_f1ts->contentNotNullBase());
667 int locId(pmptpd->getFather()->locIdOfLeaf(pmptpd));
668 MEDFileFieldPerMeshPerTypePerDisc *pmtdToModify(ct->getLeafGivenMeshAndTypeAndLocId(_lin->getName(),_gt,locId));
669 std::string pflName(pmptpd->getProfile());
670 _pfls_to_be_updated.push_back(pflName);
671 std::map< std::string, PFLData >::iterator itCache(_cache.find(pflName));
672 if(itCache!=_cache.end())
674 updateData(pmtdToModify,(*itCache).second.getNbOfAddPtsInPfl());
677 MCAuto<DataArrayIdType> pfl;
679 pfl=DataArrayIdType::Range(0,pmptpd->getNumberOfVals(),1);
681 pfl=_lin_globs->getProfile(pflName)->deepCopy();
683 MCAuto<MEDCouplingUMesh> mesh3D(_lin->getMeshAtLevel(0)),mesh3DQuadratic(_quad->getMeshAtLevel(0));
684 MCAuto<DataArrayIdType> cellIds(mesh3D->getCellIdsLyingOnNodes(pfl->begin(),pfl->end(),true));
685 MCAuto<MEDCouplingUMesh> mesh3DQuadraticRestricted(mesh3DQuadratic->buildPartOfMySelf(cellIds->begin(),cellIds->end(),true));
686 MCAuto<DataArrayIdType> mesh3DQuadraticRestrictedNodeIds(mesh3DQuadraticRestricted->computeFetchedNodeIds());
687 mesh3DQuadraticRestrictedNodeIds->checkMonotonic(true);
688 MCAuto<DataArrayIdType> newPtsIds(mesh3DQuadraticRestrictedNodeIds->buildSubstraction(pfl));
689 MCAuto<MEDCoupling1SGTUMesh> allSeg3;
691 MCAuto<DataArrayIdType> a,b,c,d;
692 MCAuto<MEDCouplingUMesh> seg3Tmp(mesh3DQuadraticRestricted->explodeIntoEdges(a,b,c,d));
693 allSeg3=MEDCoupling1SGTUMesh::New(seg3Tmp);
695 if(allSeg3->getCellModelEnum()!=INTERP_KERNEL::NORM_SEG3)
696 throw INTERP_KERNEL::Exception("MEDFileFieldLin2QuadVisitor::newPerMeshPerTypePerDisc : invalid situation where SEG3 expected !");
697 MCAuto<DataArrayIdType> midPts,cellSeg3Ids,matrix;
699 DataArrayIdType *nodeConn(allSeg3->getNodalConnectivity());
700 nodeConn->rearrange(3);
702 std::vector<std::size_t> v(1,2);
703 midPts=nodeConn->keepSelectedComponents(v);
705 cellSeg3Ids=DataArrayIdType::FindPermutationFromFirstToSecond(midPts,newPtsIds);
707 std::vector<std::size_t> v(2); v[0]=0; v[1]=1;
708 MCAuto<DataArrayIdType> tmp(nodeConn->keepSelectedComponents(v));
709 matrix=tmp->selectByTupleId(cellSeg3Ids->begin(),cellSeg3Ids->end());
711 nodeConn->rearrange(1);
713 MCAuto<DataArrayIdType> pflq;
716 std::vector<const DataArrayIdType *> vs(2);
717 vs[0]=pfl; vs[1]=newPtsIds;
718 pflq=DataArrayIdType::Aggregate(vs);
719 pflq->setName(pflName);
721 PFLData pdata(matrix,pflq,newPtsIds->getNumberOfTuples());
722 _cache[pflName]=pdata;
723 updateData(pmtdToModify,pdata.getNbOfAddPtsInPfl());
726 void MEDFileFieldLin2QuadVisitor::updateData(MEDFileFieldPerMeshPerTypePerDisc *pmtd, mcIdType deltaNbNodes)
728 pmtd->incrementNbOfVals(deltaNbNodes);
731 void MEDFileFieldLin2QuadVisitor::newPerMeshPerTypeEntry(const MEDFileFieldPerMeshPerTypeCommon *pmpt)
733 const MEDFileFieldPerMeshPerType *pmpt2(dynamic_cast<const MEDFileFieldPerMeshPerType *>(pmpt));
735 throw INTERP_KERNEL::Exception("MEDFileFieldLin2QuadVisitor::newPerMeshPerTypeEntry : not managed for structure elements !");
736 if(pmpt2->getNumberOfLoc()!=1)
737 throw INTERP_KERNEL::Exception("MEDFileFieldLin2QuadVisitor::newPerMeshPerTypeEntry : not managed for multi discr per timestep !");
738 _gt=pmpt->getGeoType();
741 void MEDFileFieldLin2QuadVisitor::newMeshEntry(const MEDFileFieldPerMesh *fpm)
743 if(fpm->getMeshName()!=_lin->getName())
744 throw INTERP_KERNEL::Exception("MEDFileFieldLin2QuadVisitor::newMeshEntry : mismatch into meshName !");
747 void MEDFileFieldLin2QuadVisitor::newTimeStepEntry(const MEDFileAnyTypeField1TSWithoutSDA *ts)
749 _1ts_update_requested=false; _pfls_to_be_updated.clear();
752 const MEDFileField1TSWithoutSDA *tsd(dynamic_cast<const MEDFileField1TSWithoutSDA *>(ts));
755 MCAuto<MEDFileAnyTypeField1TSWithoutSDA> contentCpy(ts->deepCopy());
756 MCAuto<MEDFileField1TSWithoutSDA> contentCpy2(DynamicCastSafe<MEDFileAnyTypeField1TSWithoutSDA,MEDFileField1TSWithoutSDA>(contentCpy));
757 if(contentCpy2.isNull())
759 _cur_f1ts=MEDFileField1TS::New(*contentCpy2,true);
760 _cur_f1ts->deepCpyGlobs(*_lin_globs);
763 void MEDFileFieldLin2QuadVisitor::endTimeStepEntry(const MEDFileAnyTypeField1TSWithoutSDA *ts)
765 if(_cur_f1ts.isNull())
767 if(_1ts_update_requested)
769 MCAuto<DataArrayIdType> matrix,oldPfl;
770 for(std::vector<std::string>::const_iterator it=_pfls_to_be_updated.begin();it!=_pfls_to_be_updated.end();it++)
772 std::map< std::string, PFLData >::const_iterator it2(_cache.find(*it));
773 if(it2==_cache.end())
774 throw INTERP_KERNEL::Exception("MEDFileFieldLin2QuadVisitor::endTimeStepEntry : invalid situation !");
775 matrix=(*it2).second.getMatrix();
778 int locId(_cur_f1ts->getProfileId(*it));
779 oldPfl.takeRef(_cur_f1ts->getProfile(*it));
781 std::vector<int> locToKill(1,locId);
782 _cur_f1ts->killProfileIds(locToKill);
784 _cur_f1ts->appendProfile((*it2).second.getProfile());
786 DataArrayDouble *arr(_cur_f1ts->getUndergroundDataArray());
787 MCAuto<DataArrayDouble> res;
789 std::vector<std::size_t> v(1,0),v2(1,1);
790 MCAuto<DataArrayIdType> pts0(matrix->keepSelectedComponents(v));
791 MCAuto<DataArrayIdType> pts1(matrix->keepSelectedComponents(v2));
792 if(oldPfl.isNotNull())
794 pts0=oldPfl->findIdForEach(pts0->begin(),pts0->end());
795 pts1=oldPfl->findIdForEach(pts1->begin(),pts1->end());
797 MCAuto<DataArrayDouble> part0(arr->selectByTupleId(*pts0));
798 MCAuto<DataArrayDouble> part1(arr->selectByTupleId(*pts1));
799 res=DataArrayDouble::Add(part0,part1);
800 res->applyLin(0.5,0.);
802 res=DataArrayDouble::Aggregate(arr,res);
803 _cur_f1ts->setArray(res);
805 if(_cur_fmts.isNotNull())
806 { _cur_fmts->pushBackTimeStep(_cur_f1ts); }
807 _1ts_update_requested=false;
811 * \a newQuad is expected to be the result of MEDFileUMesh::linearToQuadratic of \a oldLin
813 MCAuto<MEDFileFields> MEDFileFields::linearToQuadratic(const MEDFileMeshes *oldLin, const MEDFileMeshes *newQuad) const
815 if(!oldLin || !newQuad)
816 throw INTERP_KERNEL::Exception("MEDFileFields::linearToQuadratic : input meshes must be non NULL !");
817 MCAuto<MEDFileFields> ret(MEDFileFields::New());
818 for(int i=0;i<oldLin->getNumberOfMeshes();i++)
820 MEDFileMesh *mm(oldLin->getMeshAtPos(i));
823 MEDFileUMesh *mmu(dynamic_cast<MEDFileUMesh *>(mm));
826 MEDFileMesh *mmq(newQuad->getMeshWithName(mmu->getName()));
827 MEDFileUMesh *mmqu(dynamic_cast<MEDFileUMesh *>(mmq));
830 std::ostringstream oss; oss << "MEDFileFields::linearToQuadratic : mismatch of name between input meshes for name \"" << mmu->getName() << "\"";
831 throw INTERP_KERNEL::Exception(oss.str());
833 MEDFileFieldLin2QuadVisitor vis(mmu,mmqu,this,ret);
839 MEDFileAnyTypeFieldMultiTS *MEDFileFields::getFieldAtPos(int i) const
841 if(i<0 || i>=(int)_fields.size())
843 std::ostringstream oss; oss << "MEDFileFields::getFieldAtPos : Invalid given id in input (" << i << ") should be in [0," << _fields.size() << ") !";
844 throw INTERP_KERNEL::Exception(oss.str());
846 const MEDFileAnyTypeFieldMultiTSWithoutSDA *fmts=_fields[i];
849 MCAuto<MEDFileAnyTypeFieldMultiTS> ret;
850 const MEDFileFieldMultiTSWithoutSDA *fmtsC(dynamic_cast<const MEDFileFieldMultiTSWithoutSDA *>(fmts));
851 const MEDFileIntFieldMultiTSWithoutSDA *fmtsC2(dynamic_cast<const MEDFileIntFieldMultiTSWithoutSDA *>(fmts));
852 const MEDFileFloatFieldMultiTSWithoutSDA *fmtsC3(dynamic_cast<const MEDFileFloatFieldMultiTSWithoutSDA *>(fmts));
854 ret=MEDFileFieldMultiTS::New(*fmtsC,false);
856 ret=MEDFileIntFieldMultiTS::New(*fmtsC2,false);
858 ret=MEDFileFloatFieldMultiTS::New(*fmtsC3,false);
861 std::ostringstream oss; oss << "MEDFileFields::getFieldAtPos : At pos #" << i << " field is neither double (FLOAT64) nor float (FLOAT32) nor integer (INT32) !";
862 throw INTERP_KERNEL::Exception(oss.str());
864 ret->shallowCpyGlobs(*this);
869 * Return a shallow copy of \a this reduced to the fields ids defined in [ \a startIds , endIds ).
870 * This method is accessible in python using __getitem__ with a list in input.
871 * \return a new object that the caller should deal with.
873 MEDFileFields *MEDFileFields::buildSubPart(const int *startIds, const int *endIds) const
875 MCAuto<MEDFileFields> ret=shallowCpy();
876 std::size_t sz=std::distance(startIds,endIds);
877 std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> > fields(sz);
879 for(const int *i=startIds;i!=endIds;i++,j++)
881 if(*i<0 || *i>=(int)_fields.size())
883 std::ostringstream oss; oss << "MEDFileFields::buildSubPart : Invalid given id in input (" << *i << ") should be in [0," << _fields.size() << ") !";
884 throw INTERP_KERNEL::Exception(oss.str());
886 fields[j]=_fields[*i];
892 MEDFileAnyTypeFieldMultiTS *MEDFileFields::getFieldWithName(const std::string& fieldName) const
894 return getFieldAtPos(getPosFromFieldName(fieldName));
898 * This method removes, if any, fields in \a this having no time steps.
899 * If there is one or more than one such field in \a this true is returned and those fields will not be referenced anymore in \a this.
901 * If false is returned \a this does not contain such fields. If false is returned this method can be considered as const.
903 bool MEDFileFields::removeFieldsWithoutAnyTimeStep()
905 std::vector<MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> > newFields;
906 for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
908 const MEDFileAnyTypeFieldMultiTSWithoutSDA *elt(*it);
911 if(elt->getNumberOfTS()>0)
912 newFields.push_back(*it);
915 if(_fields.size()==newFields.size())
922 * This method returns a new object containing part of \a this fields lying on mesh name specified by the input parameter \a meshName.
923 * This method can be seen as a filter applied on \a this, that returns an object containing
924 * reduced the list of fields compared to those in \a this. The returned object is a new object but the object on which it lies are only
925 * shallow copied from \a this.
927 * \param [in] meshName - the name of the mesh on w
928 * \return a new object that the caller should deal with.
930 MEDFileFields *MEDFileFields::partOfThisLyingOnSpecifiedMeshName(const std::string& meshName) const
932 MCAuto<MEDFileFields> ret(MEDFileFields::New());
933 for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
935 const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur(*it);
938 if(cur->getMeshName()==meshName)
941 MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> cur2(const_cast<MEDFileAnyTypeFieldMultiTSWithoutSDA *>(cur));
942 ret->_fields.push_back(cur2);
945 ret->shallowCpyOnlyUsedGlobs(*this);
950 * This method returns a new object containing part of \a this fields lying ** exactly ** on the time steps specified by input parameter \a timeSteps.
951 * Input time steps are specified using a pair of integer (iteration, order).
952 * This method can be seen as a filter applied on \a this, that returns an object containing the same number of fields than those in \a this,
953 * but for each multitimestep only the time steps in \a timeSteps are kept.
954 * Typically the input parameter \a timeSteps comes from the call of MEDFileFields::getCommonIterations.
956 * The returned object points to shallow copy of elements in \a this.
958 * \param [in] timeSteps - the time steps given by a vector of pair of integers (iteration,order)
959 * \throw If there is a field in \a this that is \b not defined on a time step in the input \a timeSteps.
960 * \sa MEDFileFields::getCommonIterations, MEDFileFields::partOfThisNotLyingOnSpecifiedTimeSteps
962 MEDFileFields *MEDFileFields::partOfThisLyingOnSpecifiedTimeSteps(const std::vector< std::pair<int,int> >& timeSteps) const
964 MCAuto<MEDFileFields> ret(MEDFileFields::New());
965 for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
967 const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur(*it);
970 MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> elt=cur->partOfThisLyingOnSpecifiedTimeSteps(timeSteps);
971 ret->_fields.push_back(elt);
973 ret->shallowCpyOnlyUsedGlobs(*this);
978 * \sa MEDFileFields::getCommonIterations, MEDFileFields::partOfThisLyingOnSpecifiedTimeSteps
980 MEDFileFields *MEDFileFields::partOfThisNotLyingOnSpecifiedTimeSteps(const std::vector< std::pair<int,int> >& timeSteps) const
982 MCAuto<MEDFileFields> ret=MEDFileFields::New();
983 for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
985 const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur(*it);
988 MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> elt=cur->partOfThisNotLyingOnSpecifiedTimeSteps(timeSteps);
989 if(elt->getNumberOfTS()!=0)
990 ret->_fields.push_back(elt);
992 ret->shallowCpyOnlyUsedGlobs(*this);
996 bool MEDFileFields::presenceOfStructureElements() const
998 for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
999 if((*it).isNotNull())
1000 if((*it)->presenceOfStructureElements())
1005 void MEDFileFields::killStructureElements()
1007 std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> > ret;
1008 for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
1009 if((*it).isNotNull())
1011 if((*it)->presenceOfStructureElements())
1013 if(!(*it)->onlyStructureElements())
1015 (*it)->killStructureElements();
1027 void MEDFileFields::keepOnlyStructureElements()
1029 std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> > ret;
1030 for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
1031 if((*it).isNotNull())
1033 if((*it)->presenceOfStructureElements())
1035 if(!(*it)->onlyStructureElements())
1036 (*it)->keepOnlyStructureElements();
1043 void MEDFileFields::keepOnlyOnMeshSE(const std::string& meshName, const std::string& seName)
1045 std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> > ret;
1046 for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
1047 if((*it).isNotNull())
1049 if((*it)->getMeshName()!=meshName)
1051 std::vector< std::pair<std::string,std::string> > ps;
1052 (*it)->getMeshSENames(ps);
1053 std::pair<std::string,std::string> p(meshName,seName);
1054 if(std::find(ps.begin(),ps.end(),p)!=ps.end())
1055 (*it)->keepOnlyOnSE(seName);
1061 void MEDFileFields::getMeshSENames(std::vector< std::pair<std::string,std::string> >& ps) const
1063 for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
1064 if((*it).isNotNull())
1065 (*it)->getMeshSENames(ps);
1068 void MEDFileFields::blowUpSE(MEDFileMeshes *ms, const MEDFileStructureElements *ses)
1070 MEDFileBlowStrEltUp::DealWithSE(this,ms,ses);
1073 MCAuto<MEDFileFields> MEDFileFields::partOfThisOnStructureElements() const
1075 MCAuto<MEDFileFields> ret(deepCopy());
1076 ret->keepOnlyStructureElements();
1080 MCAuto<MEDFileFields> MEDFileFields::partOfThisLyingOnSpecifiedMeshSEName(const std::string& meshName, const std::string& seName) const
1082 MCAuto<MEDFileFields> ret(deepCopy());
1083 ret->keepOnlyOnMeshSE(meshName,seName);
1087 void MEDFileFields::aggregate(const MEDFileFields& other)
1089 int nbFieldsToAdd(other.getNumberOfFields());
1090 std::vector<std::string> fsn(getFieldsNames());
1091 for(int i=0;i<nbFieldsToAdd;i++)
1093 MCAuto<MEDFileAnyTypeFieldMultiTS> elt(other.getFieldAtPos(i));
1094 std::string name(elt->getName());
1095 if(std::find(fsn.begin(),fsn.end(),name)!=fsn.end())
1097 std::ostringstream oss; oss << "MEDFileFields::aggregate : name \"" << name << "\" already appears !";
1098 throw INTERP_KERNEL::Exception(oss.str());
1104 MEDFileFieldsIterator *MEDFileFields::iterator()
1106 return new MEDFileFieldsIterator(this);
1109 int MEDFileFields::getPosFromFieldName(const std::string& fieldName) const
1111 std::string tmp(fieldName);
1112 std::vector<std::string> poss;
1113 for(unsigned int i=0;i<_fields.size();i++)
1115 const MEDFileAnyTypeFieldMultiTSWithoutSDA *f(_fields[i]);
1118 std::string fname(f->getName());
1122 poss.push_back(fname);
1125 std::ostringstream oss; oss << "MEDFileFields::getPosFromFieldName : impossible to find field '" << tmp << "' in this ! Possibilities are : ";
1126 std::copy(poss.begin(),poss.end(),std::ostream_iterator<std::string>(oss,", "));
1128 throw INTERP_KERNEL::Exception(oss.str());
1131 MEDFileFieldsIterator::MEDFileFieldsIterator(MEDFileFields *fs):_fs(fs),_iter_id(0),_nb_iter(0)
1136 _nb_iter=fs->getNumberOfFields();
1140 MEDFileFieldsIterator::~MEDFileFieldsIterator()
1144 MEDFileAnyTypeFieldMultiTS *MEDFileFieldsIterator::nextt()
1146 if(_iter_id<_nb_iter)
1148 MEDFileFields *fs(_fs);
1150 return fs->getFieldAtPos(_iter_id++);