1 // Copyright (C) 2007-2016 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 (CEA/DEN)
21 #include "MEDFileField.txx"
22 #include "MEDFileMesh.hxx"
23 #include "MEDLoaderBase.hxx"
24 #include "MEDLoaderTraits.hxx"
25 #include "MEDFileUtilities.hxx"
26 #include "MEDFileSafeCaller.txx"
27 #include "MEDFileFieldOverView.hxx"
29 #include "MEDCouplingFieldDouble.hxx"
30 #include "MEDCouplingFieldTemplate.hxx"
31 #include "MEDCouplingFieldDiscretization.hxx"
33 #include "InterpKernelAutoPtr.hxx"
34 #include "CellModel.hxx"
39 extern med_geometry_type typmai[MED_N_CELL_FIXED_GEO];
40 extern INTERP_KERNEL::NormalizedCellType typmai2[MED_N_CELL_FIXED_GEO];
41 extern med_geometry_type typmainoeud[1];
42 extern med_geometry_type typmai3[34];
44 using namespace MEDCoupling;
46 template class MEDFileField1TSTemplateWithoutSDA<int>;
47 template class MEDFileField1TSTemplateWithoutSDA<double>;
49 const char MEDFileField1TSWithoutSDA::TYPE_STR[]="FLOAT64";
50 const char MEDFileIntField1TSWithoutSDA::TYPE_STR[]="INT32";
52 MEDFileFieldLoc *MEDFileFieldLoc::New(med_idt fid, const std::string& locName)
54 return new MEDFileFieldLoc(fid,locName);
57 MEDFileFieldLoc *MEDFileFieldLoc::New(med_idt fid, int id)
59 return new MEDFileFieldLoc(fid,id);
62 MEDFileFieldLoc *MEDFileFieldLoc::New(const std::string& locName, INTERP_KERNEL::NormalizedCellType geoType, const std::vector<double>& refCoo, const std::vector<double>& gsCoo, const std::vector<double>& w)
64 return new MEDFileFieldLoc(locName,geoType,refCoo,gsCoo,w);
67 MEDFileFieldLoc::MEDFileFieldLoc(med_idt fid, const std::string& locName):_name(locName)
69 med_geometry_type geotype;
70 med_geometry_type sectiongeotype;
72 INTERP_KERNEL::AutoPtr<char> geointerpname(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE));
73 INTERP_KERNEL::AutoPtr<char> sectionmeshname(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE));
74 MEDlocalizationInfoByName(fid,locName.c_str(),&geotype,&_dim,&_nb_gauss_pt,geointerpname,sectionmeshname,&nsectionmeshcell,§iongeotype);
75 _geo_type=(INTERP_KERNEL::NormalizedCellType)(std::distance(typmai3,std::find(typmai3,typmai3+34,geotype)));
76 const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel(_geo_type));
77 _nb_node_per_cell=cm.getNumberOfNodes();
78 _ref_coo.resize(_dim*_nb_node_per_cell);
79 _gs_coo.resize(_dim*_nb_gauss_pt);
80 _w.resize(_nb_gauss_pt);
81 MEDlocalizationRd(fid,locName.c_str(),MED_FULL_INTERLACE,&_ref_coo[0],&_gs_coo[0],&_w[0]);
84 MEDFileFieldLoc::MEDFileFieldLoc(med_idt fid, int id)
86 med_geometry_type geotype;
87 med_geometry_type sectiongeotype;
89 INTERP_KERNEL::AutoPtr<char> locName(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE));
90 INTERP_KERNEL::AutoPtr<char> geointerpname(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE));
91 INTERP_KERNEL::AutoPtr<char> sectionmeshname(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE));
92 MEDlocalizationInfo(fid,id+1,locName,&geotype,&_dim,&_nb_gauss_pt,geointerpname,sectionmeshname,&nsectionmeshcell,§iongeotype);
94 _geo_type=(INTERP_KERNEL::NormalizedCellType)(std::distance(typmai3,std::find(typmai3,typmai3+34,geotype)));
95 const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel(_geo_type));
96 _nb_node_per_cell=cm.getNumberOfNodes();
97 _ref_coo.resize(_dim*_nb_node_per_cell);
98 _gs_coo.resize(_dim*_nb_gauss_pt);
99 _w.resize(_nb_gauss_pt);
100 MEDlocalizationRd(fid,locName,MED_FULL_INTERLACE,&_ref_coo[0],&_gs_coo[0],&_w[0]);
103 MEDFileFieldLoc::MEDFileFieldLoc(const std::string& locName, INTERP_KERNEL::NormalizedCellType geoType,
104 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),
107 const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel(_geo_type));
108 _dim=cm.getDimension();
109 _nb_node_per_cell=cm.getNumberOfNodes();
110 _nb_gauss_pt=_w.size();
113 MEDFileFieldLoc *MEDFileFieldLoc::deepCopy() const
115 return new MEDFileFieldLoc(*this);
118 std::size_t MEDFileFieldLoc::getHeapMemorySizeWithoutChildren() const
120 return (_ref_coo.capacity()+_gs_coo.capacity()+_w.capacity())*sizeof(double)+_name.capacity();
123 std::vector<const BigMemoryObject *> MEDFileFieldLoc::getDirectChildrenWithNull() const
125 return std::vector<const BigMemoryObject *>();
128 void MEDFileFieldLoc::simpleRepr(std::ostream& oss) const
130 static const char OFF7[]="\n ";
131 oss << "\"" << _name << "\"" << OFF7;
132 oss << "GeoType=" << INTERP_KERNEL::CellModel::GetCellModel(_geo_type).getRepr() << OFF7;
133 oss << "Dimension=" << _dim << OFF7;
134 oss << "Number of Gauss points=" << _nb_gauss_pt << OFF7;
135 oss << "Number of nodes per cell=" << _nb_node_per_cell << OFF7;
136 oss << "RefCoords="; std::copy(_ref_coo.begin(),_ref_coo.end(),std::ostream_iterator<double>(oss," ")); oss << OFF7;
137 oss << "Weights="; std::copy(_w.begin(),_w.end(),std::ostream_iterator<double>(oss," ")); oss << OFF7;
138 oss << "GaussPtsCoords="; std::copy(_gs_coo.begin(),_gs_coo.end(),std::ostream_iterator<double>(oss," ")); oss << std::endl;
141 void MEDFileFieldLoc::setName(const std::string& name)
146 bool MEDFileFieldLoc::isEqual(const MEDFileFieldLoc& other, double eps) const
148 if(_name!=other._name)
152 if(_nb_gauss_pt!=other._nb_gauss_pt)
154 if(_nb_node_per_cell!=other._nb_node_per_cell)
156 if(_geo_type!=other._geo_type)
158 if(!MEDCouplingGaussLocalization::AreAlmostEqual(_ref_coo,other._ref_coo,eps))
160 if(!MEDCouplingGaussLocalization::AreAlmostEqual(_gs_coo,other._gs_coo,eps))
162 if(!MEDCouplingGaussLocalization::AreAlmostEqual(_w,other._w,eps))
168 void MEDFileFieldLoc::writeLL(med_idt fid) const
170 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);
173 std::string MEDFileFieldLoc::repr() const
175 std::ostringstream oss; oss.precision(15);
176 const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel(_geo_type));
177 oss << "Localization \"" << _name << "\" :\n" << " - Geometric Type : " << cm.getRepr();
178 oss << "\n - Dimension : " << _dim << "\n - Number of gauss points : ";
179 oss << _nb_gauss_pt << "\n - Number of nodes in cell : " << _nb_node_per_cell;
180 oss << "\n - Ref coords are : ";
181 int sz=_ref_coo.size();
184 int nbOfTuples=sz/_dim;
185 for(int i=0;i<nbOfTuples;i++)
188 for(int j=0;j<_dim;j++)
189 { oss << _ref_coo[i*_dim+j]; if(j!=_dim-1) oss << ", "; }
194 std::copy(_ref_coo.begin(),_ref_coo.end(),std::ostream_iterator<double>(oss," "));
195 oss << "\n - Gauss coords in reference element : ";
199 int nbOfTuples=sz/_dim;
200 for(int i=0;i<nbOfTuples;i++)
203 for(int j=0;j<_dim;j++)
204 { oss << _gs_coo[i*_dim+j]; if(j!=_dim-1) oss << ", "; }
209 std::copy(_gs_coo.begin(),_gs_coo.end(),std::ostream_iterator<double>(oss," "));
210 oss << "\n - Weights of Gauss coords are : "; std::copy(_w.begin(),_w.end(),std::ostream_iterator<double>(oss," "));
214 void MEDFileFieldPerMeshPerTypePerDisc::assignFieldNoProfile(int& start, int offset, int nbOfCells, const MEDCouplingFieldDouble *field, const DataArray *arrr, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc)
216 _type=field->getTypeOfField();
222 getOrCreateAndGetArray()->setContigPartOfSelectedValuesSlice(_start,arrr,offset,offset+nbOfCells,1);
223 _end=_start+nbOfCells;
229 MCAuto<DataArrayInt> arr=field->getDiscretization()->getOffsetArr(field->getMesh());
230 const int *arrPtr=arr->getConstPointer();
231 getOrCreateAndGetArray()->setContigPartOfSelectedValuesSlice(_start,arrr,arrPtr[offset],arrPtr[offset+nbOfCells],1);
232 _end=_start+(arrPtr[offset+nbOfCells]-arrPtr[offset]);
238 const MEDCouplingFieldDiscretization *disc(field->getDiscretization());
239 const MEDCouplingGaussLocalization& gsLoc(field->getGaussLocalization(_loc_id));
240 const MEDCouplingFieldDiscretizationGauss *disc2(dynamic_cast<const MEDCouplingFieldDiscretizationGauss *>(disc));
242 throw INTERP_KERNEL::Exception("assignFieldNoProfile : invalid call to this method ! Internal Error !");
243 const DataArrayInt *dai(disc2->getArrayOfDiscIds());
244 MCAuto<DataArrayInt> dai2(disc2->getOffsetArr(field->getMesh()));
245 const int *dai2Ptr(dai2->getConstPointer());
246 int nbi(gsLoc.getWeights().size());
247 MCAuto<DataArrayInt> da2(dai->selectByTupleIdSafeSlice(offset,offset+nbOfCells,1));
248 MCAuto<DataArrayInt> da3(da2->findIdsEqual(_loc_id));
249 const int *da3Ptr(da3->getConstPointer());
250 if(da3->getNumberOfTuples()!=nbOfCells)
251 {//profile : for gauss even in NoProfile !!!
252 std::ostringstream oss; oss << "Pfl_" << nasc.getName() << "_" << INTERP_KERNEL::CellModel::GetCellModel(getGeoType()).getRepr() << "_" << _loc_id;
254 da3->setName(_profile.c_str());
255 glob.appendProfile(da3);
257 MCAuto<DataArrayInt> da4(DataArrayInt::New());
258 _nval=da3->getNbOfElems();
259 da4->alloc(_nval*nbi,1);
260 int *da4Ptr(da4->getPointer());
261 for(int i=0;i<_nval;i++)
263 int ref=dai2Ptr[offset+da3Ptr[i]];
264 for(int j=0;j<nbi;j++)
267 std::ostringstream oss2; oss2 << "Loc_" << nasc.getName() << "_" << INTERP_KERNEL::CellModel::GetCellModel(getGeoType()).getRepr() << "_" << _loc_id;
268 _localization=oss2.str();
269 getOrCreateAndGetArray()->setContigPartOfSelectedValues(_start,arrr,da4);
270 _end=_start+_nval*nbi;
271 glob.appendLoc(_localization.c_str(),getGeoType(),gsLoc.getRefCoords(),gsLoc.getGaussCoords(),gsLoc.getWeights());
275 throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::assignFieldNoProfile : not implemented yet for such discretization type of field !");
281 * Leaf method of field with profile assignement. This method is the most general one. No optimization is done here.
282 * \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).
283 * \param [in] multiTypePfl is the end user profile specified in high level API
284 * \param [in] idsInPfl is the selection into the \a multiTypePfl whole profile that corresponds to the current geometric type.
285 * \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.
286 * \b WARNING if not null the MED file profile can be subdivided again in case of Gauss points.
287 * \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.
289 void MEDFileFieldPerMeshPerTypePerDisc::assignFieldProfile(bool isPflAlone, int& start, const DataArrayInt *multiTypePfl, const DataArrayInt *idsInPfl, DataArrayInt *locIds, int nbOfEltsInWholeMesh, const MEDCouplingFieldDouble *field, const DataArray *arrr, const MEDCouplingMesh *mesh, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc)
292 _type=field->getTypeOfField();
293 std::string pflName(multiTypePfl->getName());
294 std::ostringstream oss; oss << pflName;
298 { const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(getGeoType()); oss << "_" << cm.getRepr(); }
305 throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::assignFieldProfile : existing profile with empty name !");
306 if(_type!=ON_GAUSS_PT)
308 locIds->setName(oss.str());
309 glob.appendProfile(locIds);
318 _nval=idsInPfl->getNumberOfTuples();
319 getOrCreateAndGetArray()->setContigPartOfSelectedValuesSlice(_start,arrr,0,arrr->getNumberOfTuples(),1);
325 _nval=idsInPfl->getNumberOfTuples();
326 getOrCreateAndGetArray()->setContigPartOfSelectedValues(_start,arrr,idsInPfl);
332 MCAuto<DataArrayInt> arr=field->getDiscretization()->getOffsetArr(mesh);
333 MCAuto<DataArrayInt> arr2=arr->deltaShiftIndex();
334 MCAuto<DataArrayInt> arr3=arr2->selectByTupleId(multiTypePfl->begin(),multiTypePfl->end());
335 arr3->computeOffsetsFull();
336 MCAuto<DataArrayInt> tmp=idsInPfl->buildExplicitArrByRanges(arr3);
337 int trueNval=tmp->getNumberOfTuples();
338 _nval=idsInPfl->getNumberOfTuples();
339 getOrCreateAndGetArray()->setContigPartOfSelectedValues(_start,arrr,tmp);
340 _end=_start+trueNval;
345 const MEDCouplingFieldDiscretizationGauss *disc2=dynamic_cast<const MEDCouplingFieldDiscretizationGauss *>(field->getDiscretization());
347 throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : invalid call to this method ! Internal Error !");
348 const DataArrayInt *da1=disc2->getArrayOfDiscIds();
349 const MEDCouplingGaussLocalization& gsLoc=field->getGaussLocalization(_loc_id);
350 MCAuto<DataArrayInt> da2=da1->selectByTupleId(idsInPfl->begin(),idsInPfl->end());
351 MCAuto<DataArrayInt> da3=da2->findIdsEqual(_loc_id);
352 MCAuto<DataArrayInt> da4=idsInPfl->selectByTupleId(da3->begin(),da3->end());
354 MCAuto<MEDCouplingMesh> mesh2=mesh->buildPart(multiTypePfl->begin(),multiTypePfl->end());
355 MCAuto<DataArrayInt> arr=disc2->getOffsetArr(mesh2);
357 MCAuto<DataArrayInt> tmp=DataArrayInt::New();
359 for(const int *pt=da4->begin();pt!=da4->end();pt++)
360 trueNval+=arr->getIJ(*pt+1,0)-arr->getIJ(*pt,0);
361 tmp->alloc(trueNval,1);
362 int *tmpPtr=tmp->getPointer();
363 for(const int *pt=da4->begin();pt!=da4->end();pt++)
364 for(int j=arr->getIJ(*pt,0);j<arr->getIJ(*pt+1,0);j++)
367 _nval=da4->getNumberOfTuples();
368 getOrCreateAndGetArray()->setContigPartOfSelectedValues(_start,arrr,tmp);
369 _end=_start+trueNval;
370 oss << "_loc_" << _loc_id;
373 MCAuto<DataArrayInt> da5=locIds->selectByTupleId(da3->begin(),da3->end());
374 da5->setName(oss.str());
375 glob.appendProfile(da5);
380 if(!da3->isIota(nbOfEltsInWholeMesh))
382 da3->setName(oss.str());
383 glob.appendProfile(da3);
387 std::ostringstream oss2; oss2 << "Loc_" << nasc.getName() << "_" << INTERP_KERNEL::CellModel::GetCellModel(getGeoType()).getRepr() << "_" << _loc_id;
388 _localization=oss2.str();
389 glob.appendLoc(_localization.c_str(),getGeoType(),gsLoc.getRefCoords(),gsLoc.getGaussCoords(),gsLoc.getWeights());
393 throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::assignFieldProfile : not implemented yet for such discretization type of field !");
398 void MEDFileFieldPerMeshPerTypePerDisc::assignNodeFieldNoProfile(int& start, const MEDCouplingFieldDouble *field, const DataArray *arrr, MEDFileFieldGlobsReal& glob)
401 _nval=arrr->getNumberOfTuples();
402 getOrCreateAndGetArray()->setContigPartOfSelectedValuesSlice(_start,arrr,0,_nval,1);
407 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerTypePerDisc::NewOnRead(MEDFileFieldPerMeshPerType *fath, TypeOfField type, int profileIt, const PartDefinition *pd)
409 return new MEDFileFieldPerMeshPerTypePerDisc(fath,type,profileIt,pd);
412 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerTypePerDisc::New(MEDFileFieldPerMeshPerType *fath, TypeOfField type, int locId)
414 return new MEDFileFieldPerMeshPerTypePerDisc(fath,type,locId,std::string());
417 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerTypePerDisc::New(const MEDFileFieldPerMeshPerTypePerDisc& other)
419 return new MEDFileFieldPerMeshPerTypePerDisc(other);
422 std::size_t MEDFileFieldPerMeshPerTypePerDisc::getHeapMemorySizeWithoutChildren() const
424 return _profile.capacity()+_localization.capacity()+sizeof(MEDFileFieldPerMeshPerTypePerDisc);
427 std::vector<const BigMemoryObject *> MEDFileFieldPerMeshPerTypePerDisc::getDirectChildrenWithNull() const
429 std::vector<const BigMemoryObject *> ret(1);
430 ret[0]=(const PartDefinition*)_pd;
434 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerTypePerDisc::deepCopy(MEDFileFieldPerMeshPerType *father) const
436 MCAuto<MEDFileFieldPerMeshPerTypePerDisc> ret=new MEDFileFieldPerMeshPerTypePerDisc(*this);
441 MEDFileFieldPerMeshPerTypePerDisc::MEDFileFieldPerMeshPerTypePerDisc(MEDFileFieldPerMeshPerType *fath, TypeOfField atype, int profileIt, const PartDefinition *pd)
442 try:_type(atype),_father(fath),_profile_it(profileIt),_pd(const_cast<PartDefinition *>(pd))
447 catch(INTERP_KERNEL::Exception& e)
452 MEDFileFieldPerMeshPerTypePerDisc::MEDFileFieldPerMeshPerTypePerDisc(MEDFileFieldPerMeshPerType *fath, TypeOfField type, int locId, const std::string& dummy):_type(type),_father(fath),_loc_id(locId)
456 MEDFileFieldPerMeshPerTypePerDisc::MEDFileFieldPerMeshPerTypePerDisc(const MEDFileFieldPerMeshPerTypePerDisc& other):RefCountObject(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),_profile_it(other._profile_it),_pd(other._pd),_tmp_work1(other._tmp_work1)
460 MEDFileFieldPerMeshPerTypePerDisc::MEDFileFieldPerMeshPerTypePerDisc():_type(ON_CELLS),_father(0),_start(-std::numeric_limits<int>::max()),_end(-std::numeric_limits<int>::max()),
461 _nval(-std::numeric_limits<int>::max()),_loc_id(-std::numeric_limits<int>::max())
465 void MEDFileFieldPerMeshPerTypePerDisc::goReadZeValuesInFile(med_idt fid, const std::string& fieldName, int nbOfCompo, int iteration, int order, med_entity_type menti, med_geometry_type mgeoti, unsigned char *startFeedingPtr)
467 const PartDefinition *pd(_pd);
470 INTERP_KERNEL::AutoPtr<char> locname(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE));
472 med_int nbValsInFile(MEDfieldnValueWithProfileByName(fid,fieldName.c_str(),iteration,order,menti,mgeoti,_profile.c_str(),MED_COMPACT_PFLMODE,&tmp1,locname,&nbi));
473 if(_end-_start!=nbValsInFile*nbi)
475 std::ostringstream oss; oss << "MEDFileFieldPerMeshPerTypePerDisc::goReadZeValuesInFile : The number of tuples to read is " << nbValsInFile << "*" << nbi << " (nb integration points) ! But in data structure it values " << _end-_start << " is expected !";
476 throw INTERP_KERNEL::Exception(oss.str());
478 MEDFILESAFECALLERRD0(MEDfieldValueWithProfileRd,(fid,fieldName.c_str(),iteration,order,menti,mgeoti,MED_COMPACT_PFLMODE,_profile.c_str(),MED_FULL_INTERLACE,MED_ALL_CONSTITUENT,startFeedingPtr));
482 if(!_profile.empty())
483 throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::goReadZeValuesInFile : not implemented !");
484 INTERP_KERNEL::AutoPtr<char> pflname(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE)),locname(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE));
486 int overallNval(MEDfieldnValueWithProfile(fid,fieldName.c_str(),iteration,order,menti,mgeoti,_profile_it+1,MED_COMPACT_PFLMODE,pflname,&profilesize,locname,&nbi));
487 const SlicePartDefinition *spd(dynamic_cast<const SlicePartDefinition *>(pd));
491 spd->getSlice(start,stop,step);
492 int nbOfEltsToLoad(DataArray::GetNumberOfItemGivenBES(start,stop,step,"MEDFileFieldPerMeshPerTypePerDisc::goReadZeValuesInFile"));
493 med_filter filter=MED_FILTER_INIT;
494 MEDfilterBlockOfEntityCr(fid,/*nentity*/overallNval,/*nvaluesperentity*/nbi,/*nconstituentpervalue*/nbOfCompo,
495 MED_ALL_CONSTITUENT,MED_FULL_INTERLACE,MED_COMPACT_STMODE,MED_NO_PROFILE,
496 /*start*/start+1,/*stride*/step,/*count*/1,/*blocksize*/nbOfEltsToLoad,
497 /*lastblocksize=useless because count=1*/0,&filter);
498 MEDFILESAFECALLERRD0(MEDfieldValueAdvancedRd,(fid,fieldName.c_str(),iteration,order,menti,mgeoti,&filter,startFeedingPtr));
499 MEDfilterClose(&filter);
502 const DataArrayPartDefinition *dpd(dynamic_cast<const DataArrayPartDefinition *>(pd));
505 dpd->checkConsistencyLight();
506 MCAuto<DataArrayInt> myIds(dpd->toDAI());
507 int a(myIds->getMinValueInArray()),b(myIds->getMaxValueInArray());
508 myIds=myIds->deepCopy();// WARNING deep copy here because _pd is modified by applyLin !!!
509 myIds->applyLin(1,-a);
510 int nbOfEltsToLoad(b-a+1);
511 med_filter filter=MED_FILTER_INIT;
512 {//TODO : manage int32 !
513 MCAuto<DataArrayDouble> tmp(DataArrayDouble::New());
514 tmp->alloc(nbOfEltsToLoad,nbOfCompo);
515 MEDfilterBlockOfEntityCr(fid,/*nentity*/overallNval,/*nvaluesperentity*/nbi,/*nconstituentpervalue*/nbOfCompo,
516 MED_ALL_CONSTITUENT,MED_FULL_INTERLACE,MED_COMPACT_STMODE,MED_NO_PROFILE,
517 /*start*/a+1,/*stride*/1,/*count*/1,/*blocksize*/nbOfEltsToLoad,
518 /*lastblocksize=useless because count=1*/0,&filter);
519 MEDFILESAFECALLERRD0(MEDfieldValueAdvancedRd,(fid,fieldName.c_str(),iteration,order,menti,mgeoti,&filter,reinterpret_cast<unsigned char *>(tmp->getPointer())));
520 MCAuto<DataArrayDouble> feeder(DataArrayDouble::New());
521 feeder->useExternalArrayWithRWAccess(reinterpret_cast<double *>(startFeedingPtr),_nval,nbOfCompo);
522 feeder->setContigPartOfSelectedValues(0,tmp,myIds);
524 MEDfilterClose(&filter);
527 throw INTERP_KERNEL::Exception("Not implemented yet for not slices!");
531 const MEDFileFieldPerMeshPerType *MEDFileFieldPerMeshPerTypePerDisc::getFather() const
536 void MEDFileFieldPerMeshPerTypePerDisc::loadOnlyStructureOfDataRecursively(med_idt fid, int& start, const MEDFileFieldNameScope& nasc)
538 INTERP_KERNEL::AutoPtr<char> locname(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE));
539 INTERP_KERNEL::AutoPtr<char> pflname(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE));
540 std::string fieldName(nasc.getName()),meshName(getMeshName());
541 int iteration(getIteration()),order(getOrder());
542 TypeOfField type(getType());
543 INTERP_KERNEL::NormalizedCellType geoType(getGeoType());
545 med_geometry_type mgeoti;
546 med_entity_type menti(MEDFileFieldPerMeshPerType::ConvertIntoMEDFileType(type,geoType,mgeoti));
547 int zeNVal(MEDfieldnValueWithProfile(fid,fieldName.c_str(),iteration,order,menti,mgeoti,_profile_it+1,MED_COMPACT_PFLMODE,pflname,&profilesize,locname,&nbi));
548 _profile=MEDLoaderBase::buildStringFromFortran(pflname,MED_NAME_SIZE);
549 _localization=MEDLoaderBase::buildStringFromFortran(locname,MED_NAME_SIZE);
550 const PartDefinition *pd(_pd);
557 if(!_profile.empty())
558 throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::loadOnlyStructureOfDataRecursively : profiles are not managed yet with part of def !");
559 _nval=pd->getNumberOfElems();
562 _end=start+_nval*nbi;
564 if(type==ON_CELLS && !_localization.empty())
566 if(_localization!="MED_GAUSS_ELNO")//For compatibily with MED2.3
567 setType(ON_GAUSS_PT);
570 setType(ON_GAUSS_NE);
571 _localization.clear();
576 void MEDFileFieldPerMeshPerTypePerDisc::loadBigArray(med_idt fid, const MEDFileFieldNameScope& nasc)
578 std::string fieldName(nasc.getName()),meshName(getMeshName());
579 int iteration(getIteration()),order(getOrder());
580 TypeOfField type(getType());
581 INTERP_KERNEL::NormalizedCellType geoType(getGeoType());
582 med_geometry_type mgeoti;
583 med_entity_type menti(MEDFileFieldPerMeshPerType::ConvertIntoMEDFileType(type,geoType,mgeoti));
585 throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::loadBigArray : internal error in range !");
588 DataArray *arr(getOrCreateAndGetArray());//arr is not null due to the spec of getOrCreateAndGetArray
589 if(_start<0 || _start>=arr->getNumberOfTuples())
591 std::ostringstream oss; oss << "MEDFileFieldPerMeshPerTypePerDisc::loadBigArray : Invalid start ("<< _start << ") regarding admissible range of allocated array [0," << arr->getNumberOfTuples() << ") !";
592 throw INTERP_KERNEL::Exception(oss.str());
594 if(_end<0 || _end>arr->getNumberOfTuples())
596 std::ostringstream oss; oss << "MEDFileFieldPerMeshPerTypePerDisc::loadBigArray : Invalid start ("<< _start << ") regarding admissible range of allocated array [0," << arr->getNumberOfTuples() << "] !";
597 throw INTERP_KERNEL::Exception(oss.str());
599 int nbOfCompo(arr->getNumberOfComponents());
600 DataArrayDouble *arrD(dynamic_cast<DataArrayDouble *>(arr));
603 double *startFeeding(arrD->getPointer()+_start*nbOfCompo);
604 goReadZeValuesInFile(fid,fieldName,nbOfCompo,iteration,order,menti,mgeoti,reinterpret_cast<unsigned char*>(startFeeding));
607 DataArrayInt *arrI(dynamic_cast<DataArrayInt *>(arr));
610 int *startFeeding(arrI->getPointer()+_start*nbOfCompo);
611 goReadZeValuesInFile(fid,fieldName,nbOfCompo,iteration,order,menti,mgeoti,reinterpret_cast<unsigned char*>(startFeeding));
614 throw INTERP_KERNEL::Exception("Error on array reading ! Unrecognized type of field ! Should be in FLOAT64 or INT32 !");
618 * Set a \c this->_start **and** \c this->_end keeping the same delta between the two.
620 void MEDFileFieldPerMeshPerTypePerDisc::setNewStart(int newValueOfStart)
622 int delta=_end-_start;
623 _start=newValueOfStart;
627 int MEDFileFieldPerMeshPerTypePerDisc::getIteration() const
629 return _father->getIteration();
632 int MEDFileFieldPerMeshPerTypePerDisc::getOrder() const
634 return _father->getOrder();
637 double MEDFileFieldPerMeshPerTypePerDisc::getTime() const
639 return _father->getTime();
642 std::string MEDFileFieldPerMeshPerTypePerDisc::getMeshName() const
644 return _father->getMeshName();
647 void MEDFileFieldPerMeshPerTypePerDisc::simpleRepr(int bkOffset, std::ostream& oss, int id) const
649 const char startLine[]=" ## ";
650 std::string startLine2(bkOffset,' ');
651 startLine2+=startLine;
652 MEDCouplingFieldDiscretization *tmp=MEDCouplingFieldDiscretization::New(_type);
653 oss << startLine2 << "Localization #" << id << "." << std::endl;
654 oss << startLine2 << " Type=" << tmp->getRepr() << "." << std::endl;
656 oss << startLine2 << " This type discretization lies on profile : \"" << _profile << "\" and on the following localization : \"" << _localization << "\"." << std::endl;
657 oss << startLine2 << " This type discretization has " << _end-_start << " tuples (start=" << _start << ", end=" << _end << ")." << std::endl;
658 oss << startLine2 << " This type discretization has " << (_end-_start)/_nval << " integration points." << std::endl;
661 TypeOfField MEDFileFieldPerMeshPerTypePerDisc::getType() const
666 void MEDFileFieldPerMeshPerTypePerDisc::fillTypesOfFieldAvailable(std::set<TypeOfField>& types) const
671 void MEDFileFieldPerMeshPerTypePerDisc::setType(TypeOfField newType)
676 INTERP_KERNEL::NormalizedCellType MEDFileFieldPerMeshPerTypePerDisc::getGeoType() const
678 return _father->getGeoType();
681 int MEDFileFieldPerMeshPerTypePerDisc::getNumberOfComponents() const
683 return _father->getNumberOfComponents();
686 int MEDFileFieldPerMeshPerTypePerDisc::getNumberOfTuples() const
691 DataArray *MEDFileFieldPerMeshPerTypePerDisc::getOrCreateAndGetArray()
693 return _father->getOrCreateAndGetArray();
696 const DataArray *MEDFileFieldPerMeshPerTypePerDisc::getOrCreateAndGetArray() const
698 const MEDFileFieldPerMeshPerType *fath=_father;
699 return fath->getOrCreateAndGetArray();
702 const std::vector<std::string>& MEDFileFieldPerMeshPerTypePerDisc::getInfo() const
704 return _father->getInfo();
707 std::string MEDFileFieldPerMeshPerTypePerDisc::getProfile() const
712 void MEDFileFieldPerMeshPerTypePerDisc::setProfile(const std::string& newPflName)
717 std::string MEDFileFieldPerMeshPerTypePerDisc::getLocalization() const
719 return _localization;
722 void MEDFileFieldPerMeshPerTypePerDisc::setLocalization(const std::string& newLocName)
724 _localization=newLocName;
727 void MEDFileFieldPerMeshPerTypePerDisc::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
729 for(std::vector< std::pair<std::vector<std::string>, std::string > >::const_iterator it2=mapOfModif.begin();it2!=mapOfModif.end();it2++)
731 if(std::find((*it2).first.begin(),(*it2).first.end(),_profile)!=(*it2).first.end())
733 _profile=(*it2).second;
739 void MEDFileFieldPerMeshPerTypePerDisc::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
741 for(std::vector< std::pair<std::vector<std::string>, std::string > >::const_iterator it2=mapOfModif.begin();it2!=mapOfModif.end();it2++)
743 if(std::find((*it2).first.begin(),(*it2).first.end(),_localization)!=(*it2).first.end())
745 _localization=(*it2).second;
751 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
755 dads.push_back(std::pair<int,int>(_start,_end));
756 geoTypes.push_back(getGeoType());
761 pfls.push_back(glob->getProfile(_profile.c_str()));
763 if(_localization.empty())
767 locs.push_back(glob->getLocalizationId(_localization.c_str()));
771 void MEDFileFieldPerMeshPerTypePerDisc::fillValues(int discId, int& startEntryId, std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
773 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));
777 void MEDFileFieldPerMeshPerTypePerDisc::writeLL(med_idt fid, const MEDFileFieldNameScope& nasc) const
779 TypeOfField type=getType();
780 INTERP_KERNEL::NormalizedCellType geoType=getGeoType();
781 med_geometry_type mgeoti;
782 med_entity_type menti=MEDFileFieldPerMeshPerType::ConvertIntoMEDFileType(type,geoType,mgeoti);
783 const DataArray *arr=getOrCreateAndGetArray();
785 throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::writeLL : no array set !");
786 if(!arr->isAllocated())
787 throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::writeLL : the array to be written is not allocated !");
788 const DataArrayDouble *arrD=dynamic_cast<const DataArrayDouble *>(arr);
789 const DataArrayInt *arrI=dynamic_cast<const DataArrayInt *>(arr);
790 const unsigned char *locToWrite=0;
792 locToWrite=reinterpret_cast<const unsigned char *>(arrD->getConstPointer()+_start*arr->getNumberOfComponents());
794 locToWrite=reinterpret_cast<const unsigned char *>(arrI->getConstPointer()+_start*arr->getNumberOfComponents());
796 throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::writeLL : not recognized type of values ! Supported are FLOAT64 and INT32 !");
797 MEDFILESAFECALLERWR0(MEDfieldValueWithProfileWr,(fid,nasc.getName().c_str(),getIteration(),getOrder(),getTime(),menti,mgeoti,
798 MED_COMPACT_PFLMODE,_profile.c_str(),_localization.c_str(),MED_FULL_INTERLACE,MED_ALL_CONSTITUENT,_nval,
802 void MEDFileFieldPerMeshPerTypePerDisc::getCoarseData(TypeOfField& type, std::pair<int,int>& dad, std::string& pfl, std::string& loc) const
807 dad.first=_start; dad.second=_end;
811 * \param [in] codeOfMesh is of format returned by MEDCouplingUMesh::getDistributionOfTypes. And for each *i* oldCode[3*i+2] gives the position (MEDFileUMesh::PutInThirdComponentOfCodeOffset).
812 * This code corresponds to the distribution of types in the corresponding mesh.
813 * \param [out] ptToFill memory zone where the output will be stored.
814 * \return the size of data pushed into output param \a ptToFill
816 int MEDFileFieldPerMeshPerTypePerDisc::fillEltIdsFromCode(int offset, const std::vector<int>& codeOfMesh, const MEDFileFieldGlobsReal& glob, int *ptToFill) const
819 std::ostringstream oss;
820 std::size_t nbOfType=codeOfMesh.size()/3;
822 for(std::size_t i=0;i<nbOfType && found==-1;i++)
823 if(getGeoType()==(INTERP_KERNEL::NormalizedCellType)codeOfMesh[3*i])
827 const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(getGeoType());
828 oss << "MEDFileFieldPerMeshPerTypePerDisc::fillEltIdsFromCode : not found geometric type " << cm.getRepr() << " in the referenced mesh of field !";
829 throw INTERP_KERNEL::Exception(oss.str());
834 if(_nval!=codeOfMesh[3*found+1])
836 const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(getGeoType());
837 oss << "MEDFileFieldPerMeshPerTypePerDisc::fillEltIdsFromCode : for geometric type " << cm.getRepr() << " number of elt ids in mesh is equal to " << _nval;
838 oss << " whereas mesh has " << codeOfMesh[3*found+1] << " for this geometric type !";
839 throw INTERP_KERNEL::Exception(oss.str());
841 for(int ii=codeOfMesh[3*found+2];ii<codeOfMesh[3*found+2]+_nval;ii++)
846 const DataArrayInt *pfl=glob.getProfile(_profile.c_str());
847 if(pfl->getNumberOfTuples()!=_nval)
849 const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(getGeoType());
850 oss << "MEDFileFieldPerMeshPerTypePerDisc::fillEltIdsFromCode : for geometric type " << cm.getRepr() << ", field is defined on profile \"" << _profile << "\" and size of profile is ";
852 oss << pfl->getNumberOfTuples() << " whereas the number of ids is set to " << _nval << " for this geometric type !";
853 throw INTERP_KERNEL::Exception(oss.str());
855 int offset2=codeOfMesh[3*found+2];
856 for(const int *pflId=pfl->begin();pflId!=pfl->end();pflId++)
858 if(*pflId<codeOfMesh[3*found+1])
859 *work++=offset2+*pflId;
865 int MEDFileFieldPerMeshPerTypePerDisc::fillTupleIds(int *ptToFill) const
867 for(int i=_start;i<_end;i++)
872 int MEDFileFieldPerMeshPerTypePerDisc::ConvertType(TypeOfField type, int locId)
883 throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::ConvertType : not managed type of field !");
887 std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> > MEDFileFieldPerMeshPerTypePerDisc::SplitPerDiscretization(const std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>& entries)
890 std::map<std::pair<std::string,TypeOfField>,int> m;
891 std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> > ret;
892 for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=entries.begin();it!=entries.end();it++)
893 if(m.find(std::pair<std::string,TypeOfField>((*it)->getLocalization(),(*it)->getType()))==m.end())
894 m[std::pair<std::string,TypeOfField>((*it)->getLocalization(),(*it)->getType())]=id++;
896 for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=entries.begin();it!=entries.end();it++)
897 ret[m[std::pair<std::string,TypeOfField>((*it)->getLocalization(),(*it)->getType())]].push_back(*it);
902 * - \c this->_loc_id mutable attribute is used for elt id in mesh offsets.
904 * \param [in] offset the offset id used to take into account that \a result is not compulsary empty in input
905 * \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.
906 * \param [in] explicitIdsInMesh ids in mesh of the considered chunk.
907 * \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)
908 * \param [in,out] glob if necessary by the method, new profiles can be added to it
909 * \param [in,out] arr after the call of this method \a arr is renumbered to be compliant with added entries to \a result.
910 * \param [out] result All new entries will be appended on it.
911 * \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 !)
913 bool MEDFileFieldPerMeshPerTypePerDisc::RenumberChunks(int offset, const std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>& entriesOnSameDisc,
914 const DataArrayInt *explicitIdsInMesh,
915 const std::vector<int>& newCode,
916 MEDFileFieldGlobsReal& glob, DataArrayDouble *arr,
917 std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >& result)
919 if(entriesOnSameDisc.empty())
921 TypeOfField type=entriesOnSameDisc[0]->getType();
922 int szEntities=0,szTuples=0;
923 for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=entriesOnSameDisc.begin();it!=entriesOnSameDisc.end();it++)
924 { szEntities+=(*it)->_nval; szTuples+=(*it)->_end-(*it)->_start; }
925 int nbi=szTuples/szEntities;
926 if(szTuples%szEntities!=0)
927 throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::RenumberChunks : internal error the splitting into same dicretization failed !");
928 MCAuto<DataArrayInt> renumTuples=DataArrayInt::New(); renumTuples->alloc(szTuples,1);
929 MCAuto<DataArrayInt> ranges=MEDCouplingUMesh::ComputeRangesFromTypeDistribution(newCode);
930 std::vector< MCAuto<DataArrayInt> > newGeoTypesPerChunk(entriesOnSameDisc.size());
931 std::vector< const DataArrayInt * > newGeoTypesPerChunk2(entriesOnSameDisc.size());
932 std::vector< MCAuto<DataArrayInt> > newGeoTypesPerChunk_bis(entriesOnSameDisc.size());
933 std::vector< const DataArrayInt * > newGeoTypesPerChunk3(entriesOnSameDisc.size());
934 MCAuto<DataArrayInt> newGeoTypesPerChunk4=DataArrayInt::New(); newGeoTypesPerChunk4->alloc(szEntities,nbi);
936 for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=entriesOnSameDisc.begin();it!=entriesOnSameDisc.end();it++,id++)
938 int startOfEltIdOfChunk=(*it)->_start;
939 MCAuto<DataArrayInt> newEltIds=explicitIdsInMesh->subArray(startOfEltIdOfChunk,startOfEltIdOfChunk+(*it)->_nval);
940 MCAuto<DataArrayInt> rangeIdsForChunk=newEltIds->findRangeIdForEachTuple(ranges);
941 MCAuto<DataArrayInt> idsInRrangeForChunk=newEltIds->findIdInRangeForEachTuple(ranges);
943 MCAuto<DataArrayInt> tmp=rangeIdsForChunk->duplicateEachTupleNTimes(nbi); rangeIdsForChunk->rearrange(nbi);
944 newGeoTypesPerChunk4->setPartOfValues1(tmp,(*it)->_tmp_work1-offset,(*it)->_tmp_work1+(*it)->_nval*nbi-offset,1,0,nbi,1);
946 newGeoTypesPerChunk[id]=rangeIdsForChunk; newGeoTypesPerChunk2[id]=rangeIdsForChunk;
947 newGeoTypesPerChunk_bis[id]=idsInRrangeForChunk; newGeoTypesPerChunk3[id]=idsInRrangeForChunk;
949 MCAuto<DataArrayInt> newGeoTypesEltIdsAllGather=DataArrayInt::Aggregate(newGeoTypesPerChunk2); newGeoTypesPerChunk.clear(); newGeoTypesPerChunk2.clear();
950 MCAuto<DataArrayInt> newGeoTypesEltIdsAllGather2=DataArrayInt::Aggregate(newGeoTypesPerChunk3); newGeoTypesPerChunk_bis.clear(); newGeoTypesPerChunk3.clear();
951 MCAuto<DataArrayInt> diffVals=newGeoTypesEltIdsAllGather->getDifferentValues();
952 MCAuto<DataArrayInt> renumEltIds=newGeoTypesEltIdsAllGather->buildPermArrPerLevel();
954 MCAuto<DataArrayInt> renumTupleIds=newGeoTypesPerChunk4->buildPermArrPerLevel();
956 MCAuto<DataArrayDouble> arrPart=arr->subArray(offset,offset+szTuples);
957 arrPart->renumberInPlace(renumTupleIds->begin());
958 arr->setPartOfValues1(arrPart,offset,offset+szTuples,1,0,arrPart->getNumberOfComponents(),1);
960 const int *idIt=diffVals->begin();
961 std::list<const MEDFileFieldPerMeshPerTypePerDisc *> li(entriesOnSameDisc.begin(),entriesOnSameDisc.end());
963 for(int i=0;i<diffVals->getNumberOfTuples();i++,idIt++)
965 MCAuto<DataArrayInt> ids=newGeoTypesEltIdsAllGather->findIdsEqual(*idIt);
966 MCAuto<DataArrayInt> subIds=newGeoTypesEltIdsAllGather2->selectByTupleId(ids->begin(),ids->end());
967 int nbEntityElts=subIds->getNumberOfTuples();
969 MCAuto<MEDFileFieldPerMeshPerTypePerDisc> eltToAdd=MEDFileFieldPerMeshPerTypePerDisc::
970 NewObjectOnSameDiscThanPool(type,(INTERP_KERNEL::NormalizedCellType)newCode[3*(*idIt)],subIds,!subIds->isIota(newCode[3*(*idIt)+1]),nbi,
974 result.push_back(eltToAdd);
975 offset2+=nbEntityElts*nbi;
977 ret=ret || li.empty();
982 * \param [in] typeF type of field of new chunk
983 * \param [in] geoType the geometric type of the chunk
984 * \param [in] idsOfMeshElt the entity ids of mesh (cells or nodes) of the new chunk.
985 * \param [in] isPfl specifies if a profile is requested regarding size of \a idsOfMeshElt and the number of such entities regarding underlying mesh.
986 * \param [in] nbi number of integration points
987 * \param [in] offset The offset in the **global array of data**.
988 * \param [in,out] entriesOnSameDisc the pool **on the same discretization** inside which it will be attempted to find an existing entry corresponding exactly
989 * to the new chunk to create.
990 * \param [in,out] glob the global shared info that will be requested for existing profiles or to append a new profile if needed.
991 * \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
992 * and corresponding entry erased from \a entriesOnSameDisc.
993 * \return a newly allocated chunk
995 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerTypePerDisc::NewObjectOnSameDiscThanPool(TypeOfField typeF, INTERP_KERNEL::NormalizedCellType geoType, DataArrayInt *idsOfMeshElt,
996 bool isPfl, int nbi, int offset,
997 std::list< const MEDFileFieldPerMeshPerTypePerDisc *>& entriesOnSameDisc,
998 MEDFileFieldGlobsReal& glob,
1001 int nbMeshEntities=idsOfMeshElt->getNumberOfTuples();
1002 std::list< const MEDFileFieldPerMeshPerTypePerDisc *>::iterator it=entriesOnSameDisc.begin();
1003 for(;it!=entriesOnSameDisc.end();it++)
1005 if(((INTERP_KERNEL::NormalizedCellType)(*it)->_loc_id)==geoType && (*it)->_nval==nbMeshEntities)
1009 if((*it)->_profile.empty())
1012 if(!(*it)->_profile.empty())
1014 const DataArrayInt *pfl=glob.getProfile((*it)->_profile.c_str());
1015 if(pfl->isEqualWithoutConsideringStr(*idsOfMeshElt))
1021 if(it==entriesOnSameDisc.end())
1024 MEDFileFieldPerMeshPerTypePerDisc *ret=new MEDFileFieldPerMeshPerTypePerDisc;
1026 ret->_loc_id=(int)geoType;
1027 ret->_nval=nbMeshEntities;
1029 ret->_end=ret->_start+ret->_nval*nbi;
1032 idsOfMeshElt->setName(glob.createNewNameOfPfl().c_str());
1033 glob.appendProfile(idsOfMeshElt);
1034 ret->_profile=idsOfMeshElt->getName();
1036 //tony treatment of localization
1041 notInExisting=false;
1042 MEDFileFieldPerMeshPerTypePerDisc *ret=MEDFileFieldPerMeshPerTypePerDisc::New(*(*it));
1043 ret->_loc_id=(int)geoType;
1044 ret->setNewStart(offset);
1045 entriesOnSameDisc.erase(it);
1051 MEDFileFieldPerMeshPerType *MEDFileFieldPerMeshPerType::NewOnRead(med_idt fid, MEDFileFieldPerMesh *fath, TypeOfField type, INTERP_KERNEL::NormalizedCellType geoType, const MEDFileFieldNameScope& nasc, const PartDefinition *pd)
1053 return new MEDFileFieldPerMeshPerType(fid,fath,type,geoType,nasc,pd);
1056 MEDFileFieldPerMeshPerType *MEDFileFieldPerMeshPerType::New(MEDFileFieldPerMesh *fath, INTERP_KERNEL::NormalizedCellType geoType)
1058 return new MEDFileFieldPerMeshPerType(fath,geoType);
1061 std::size_t MEDFileFieldPerMeshPerType::getHeapMemorySizeWithoutChildren() const
1063 return _field_pm_pt_pd.capacity()*sizeof(MCAuto<MEDFileFieldPerMeshPerTypePerDisc>);
1066 std::vector<const BigMemoryObject *> MEDFileFieldPerMeshPerType::getDirectChildrenWithNull() const
1068 std::vector<const BigMemoryObject *> ret;
1069 for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1070 ret.push_back((const MEDFileFieldPerMeshPerTypePerDisc *)*it);
1074 MEDFileFieldPerMeshPerType *MEDFileFieldPerMeshPerType::deepCopy(MEDFileFieldPerMesh *father) const
1076 MCAuto<MEDFileFieldPerMeshPerType> ret=new MEDFileFieldPerMeshPerType(*this);
1077 ret->_father=father;
1079 for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++,i++)
1081 if((const MEDFileFieldPerMeshPerTypePerDisc *)*it)
1082 ret->_field_pm_pt_pd[i]=(*it)->deepCopy((MEDFileFieldPerMeshPerType *)ret);
1087 void MEDFileFieldPerMeshPerType::assignFieldNoProfile(int& start, int offset, int nbOfCells, const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc)
1089 std::vector<int> pos=addNewEntryIfNecessary(field,offset,nbOfCells);
1090 for(std::vector<int>::const_iterator it=pos.begin();it!=pos.end();it++)
1091 _field_pm_pt_pd[*it]->assignFieldNoProfile(start,offset,nbOfCells,field,arr,glob,nasc);
1095 * This method is the most general one. No optimization is done here.
1096 * \param [in] multiTypePfl is the end user profile specified in high level API
1097 * \param [in] idsInPfl is the selection into the \a multiTypePfl whole profile that corresponds to the current geometric type.
1098 * \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.
1099 * \b WARNING if not null the MED file profile can be subdivided again in case of Gauss points.
1100 * \param [in] nbOfEltsInWholeMesh nb of elts of type \a this->_geo_type in \b WHOLE mesh
1101 * \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.
1103 void MEDFileFieldPerMeshPerType::assignFieldProfile(bool isPflAlone, int& start, const DataArrayInt *multiTypePfl, const DataArrayInt *idsInPfl, DataArrayInt *locIds, int nbOfEltsInWholeMesh, const MEDCouplingFieldDouble *field, const DataArray *arr, const MEDCouplingMesh *mesh, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc)
1105 std::vector<int> pos=addNewEntryIfNecessary(field,idsInPfl);
1106 for(std::vector<int>::const_iterator it=pos.begin();it!=pos.end();it++)
1107 _field_pm_pt_pd[*it]->assignFieldProfile(isPflAlone,start,multiTypePfl,idsInPfl,locIds,nbOfEltsInWholeMesh,field,arr,mesh,glob,nasc);
1110 void MEDFileFieldPerMeshPerType::assignNodeFieldNoProfile(int& start, const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob)
1112 _field_pm_pt_pd.resize(1);
1113 _field_pm_pt_pd[0]=MEDFileFieldPerMeshPerTypePerDisc::New(this,ON_NODES,-3);
1114 _field_pm_pt_pd[0]->assignNodeFieldNoProfile(start,field,arr,glob);
1117 void MEDFileFieldPerMeshPerType::assignNodeFieldProfile(int& start, const DataArrayInt *pfl, const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc)
1119 MCAuto<DataArrayInt> pfl2=pfl->deepCopy();
1120 if(!arr || !arr->isAllocated())
1121 throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerType::assignNodeFieldProfile : input array is null, or not allocated !");
1122 _field_pm_pt_pd.resize(1);
1123 _field_pm_pt_pd[0]=MEDFileFieldPerMeshPerTypePerDisc::New(this,ON_NODES,-3);
1124 _field_pm_pt_pd[0]->assignFieldProfile(true,start,pfl,pfl2,pfl2,-1,field,arr,0,glob,nasc);//mesh is not requested so 0 is send.
1127 std::vector<int> MEDFileFieldPerMeshPerType::addNewEntryIfNecessary(const MEDCouplingFieldDouble *field, int offset, int nbOfCells)
1129 TypeOfField type=field->getTypeOfField();
1130 if(type!=ON_GAUSS_PT)
1132 int locIdToFind=MEDFileFieldPerMeshPerTypePerDisc::ConvertType(type,0);
1133 int sz=_field_pm_pt_pd.size();
1135 for(int j=0;j<sz && !found;j++)
1137 if(_field_pm_pt_pd[j]->getLocId()==locIdToFind)
1139 _field_pm_pt_pd[j]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1145 _field_pm_pt_pd.resize(sz+1);
1146 _field_pm_pt_pd[sz]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1148 std::vector<int> ret(1,(int)sz);
1153 std::vector<int> ret2=addNewEntryIfNecessaryGauss(field,offset,nbOfCells);
1154 int sz2=ret2.size();
1155 std::vector<int> ret3(sz2);
1157 for(int i=0;i<sz2;i++)
1159 int sz=_field_pm_pt_pd.size();
1160 int locIdToFind=ret2[i];
1162 for(int j=0;j<sz && !found;j++)
1164 if(_field_pm_pt_pd[j]->getLocId()==locIdToFind)
1166 _field_pm_pt_pd[j]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1173 _field_pm_pt_pd.resize(sz+1);
1174 _field_pm_pt_pd[sz]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1182 std::vector<int> MEDFileFieldPerMeshPerType::addNewEntryIfNecessaryGauss(const MEDCouplingFieldDouble *field, int offset, int nbOfCells)
1184 const MEDCouplingFieldDiscretization *disc=field->getDiscretization();
1185 const MEDCouplingFieldDiscretizationGauss *disc2=dynamic_cast<const MEDCouplingFieldDiscretizationGauss *>(disc);
1187 throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : invalid call to this method ! Internal Error !");
1188 const DataArrayInt *da=disc2->getArrayOfDiscIds();
1190 throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss (no profile) : no localization ids per cell array available ! The input Gauss node field is maybe invalid !");
1191 MCAuto<DataArrayInt> da2=da->selectByTupleIdSafeSlice(offset,offset+nbOfCells,1);
1192 MCAuto<DataArrayInt> retTmp=da2->getDifferentValues();
1193 if(retTmp->presenceOfValue(-1))
1194 throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : some cells have no dicretization description !");
1195 std::vector<int> ret(retTmp->begin(),retTmp->end());
1199 std::vector<int> MEDFileFieldPerMeshPerType::addNewEntryIfNecessary(const MEDCouplingFieldDouble *field, const DataArrayInt *subCells)
1201 TypeOfField type=field->getTypeOfField();
1202 if(type!=ON_GAUSS_PT)
1204 int locIdToFind=MEDFileFieldPerMeshPerTypePerDisc::ConvertType(type,0);
1205 int sz=_field_pm_pt_pd.size();
1207 for(int j=0;j<sz && !found;j++)
1209 if(_field_pm_pt_pd[j]->getLocId()==locIdToFind)
1211 _field_pm_pt_pd[j]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1217 _field_pm_pt_pd.resize(sz+1);
1218 _field_pm_pt_pd[sz]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1220 std::vector<int> ret(1,0);
1225 std::vector<int> ret2=addNewEntryIfNecessaryGauss(field,subCells);
1226 int sz2=ret2.size();
1227 std::vector<int> ret3(sz2);
1229 for(int i=0;i<sz2;i++)
1231 int sz=_field_pm_pt_pd.size();
1232 int locIdToFind=ret2[i];
1234 for(int j=0;j<sz && !found;j++)
1236 if(_field_pm_pt_pd[j]->getLocId()==locIdToFind)
1238 _field_pm_pt_pd[j]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1245 _field_pm_pt_pd.resize(sz+1);
1246 _field_pm_pt_pd[sz]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1254 std::vector<int> MEDFileFieldPerMeshPerType::addNewEntryIfNecessaryGauss(const MEDCouplingFieldDouble *field, const DataArrayInt *subCells)
1256 const MEDCouplingFieldDiscretization *disc=field->getDiscretization();
1257 const MEDCouplingFieldDiscretizationGauss *disc2=dynamic_cast<const MEDCouplingFieldDiscretizationGauss *>(disc);
1259 throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : invalid call to this method ! Internal Error !");
1260 const DataArrayInt *da=disc2->getArrayOfDiscIds();
1262 throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : no localization ids per cell array available ! The input Gauss node field is maybe invalid !");
1263 MCAuto<DataArrayInt> da2=da->selectByTupleIdSafe(subCells->getConstPointer(),subCells->getConstPointer()+subCells->getNumberOfTuples());
1264 MCAuto<DataArrayInt> retTmp=da2->getDifferentValues();
1265 if(retTmp->presenceOfValue(-1))
1266 throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : some cells have no dicretization description !");
1267 std::vector<int> ret(retTmp->begin(),retTmp->end());
1271 const MEDFileFieldPerMesh *MEDFileFieldPerMeshPerType::getFather() const
1276 void MEDFileFieldPerMeshPerType::getDimension(int& dim) const
1278 const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel(_geo_type));
1279 int curDim((int)cm.getDimension());
1280 dim=std::max(dim,curDim);
1283 bool MEDFileFieldPerMeshPerType::isUniqueLevel(int& dim) const
1285 const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel(_geo_type));
1286 int curDim((int)cm.getDimension());
1287 if(dim!=std::numeric_limits<int>::max())
1297 void MEDFileFieldPerMeshPerType::fillTypesOfFieldAvailable(std::set<TypeOfField>& types) const
1299 for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1301 (*it)->fillTypesOfFieldAvailable(types);
1305 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
1307 int sz=_field_pm_pt_pd.size();
1308 dads.resize(sz); types.resize(sz); pfls.resize(sz); locs.resize(sz);
1309 for(int i=0;i<sz;i++)
1311 _field_pm_pt_pd[i]->getCoarseData(types[i],dads[i],pfls[i],locs[i]);
1315 int MEDFileFieldPerMeshPerType::getIteration() const
1317 return _father->getIteration();
1320 int MEDFileFieldPerMeshPerType::getOrder() const
1322 return _father->getOrder();
1325 double MEDFileFieldPerMeshPerType::getTime() const
1327 return _father->getTime();
1330 std::string MEDFileFieldPerMeshPerType::getMeshName() const
1332 return _father->getMeshName();
1335 void MEDFileFieldPerMeshPerType::simpleRepr(int bkOffset, std::ostream& oss, int id) const
1337 const char startLine[]=" ## ";
1338 std::string startLine2(bkOffset,' ');
1339 std::string startLine3(startLine2);
1340 startLine3+=startLine;
1341 if(_geo_type!=INTERP_KERNEL::NORM_ERROR)
1343 const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1344 oss << startLine3 << "Entry geometry type #" << id << " is lying on geometry types " << cm.getRepr() << "." << std::endl;
1347 oss << startLine3 << "Entry geometry type #" << id << " is lying on NODES." << std::endl;
1348 oss << startLine3 << "Entry is defined on " << _field_pm_pt_pd.size() << " localizations." << std::endl;
1350 for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++,i++)
1352 const MEDFileFieldPerMeshPerTypePerDisc *cur=(*it);
1354 cur->simpleRepr(bkOffset,oss,i);
1357 oss << startLine2 << " ## " << "Localization #" << i << " is empty !" << std::endl;
1362 void MEDFileFieldPerMeshPerType::getSizes(int& globalSz, int& nbOfEntries) const
1364 for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1366 globalSz+=(*it)->getNumberOfTuples();
1368 nbOfEntries+=(int)_field_pm_pt_pd.size();
1371 INTERP_KERNEL::NormalizedCellType MEDFileFieldPerMeshPerType::getGeoType() const
1377 int MEDFileFieldPerMeshPerType::getNumberOfComponents() const
1379 return _father->getNumberOfComponents();
1382 bool MEDFileFieldPerMeshPerType::presenceOfMultiDiscPerGeoType() const
1385 for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1387 const MEDFileFieldPerMeshPerTypePerDisc *fmtd(*it);
1394 DataArray *MEDFileFieldPerMeshPerType::getOrCreateAndGetArray()
1396 return _father->getOrCreateAndGetArray();
1399 const DataArray *MEDFileFieldPerMeshPerType::getOrCreateAndGetArray() const
1401 const MEDFileFieldPerMesh *fath=_father;
1402 return fath->getOrCreateAndGetArray();
1405 const std::vector<std::string>& MEDFileFieldPerMeshPerType::getInfo() const
1407 return _father->getInfo();
1410 std::vector<std::string> MEDFileFieldPerMeshPerType::getPflsReallyUsed() const
1412 std::vector<std::string> ret;
1413 std::set<std::string> ret2;
1414 for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1416 std::string tmp=(*it1)->getProfile();
1418 if(ret2.find(tmp)==ret2.end())
1427 std::vector<std::string> MEDFileFieldPerMeshPerType::getLocsReallyUsed() const
1429 std::vector<std::string> ret;
1430 std::set<std::string> ret2;
1431 for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1433 std::string tmp=(*it1)->getLocalization();
1434 if(!tmp.empty() && tmp!=MED_GAUSS_ELNO)
1435 if(ret2.find(tmp)==ret2.end())
1444 std::vector<std::string> MEDFileFieldPerMeshPerType::getPflsReallyUsedMulti() const
1446 std::vector<std::string> ret;
1447 std::set<std::string> ret2;
1448 for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1450 std::string tmp=(*it1)->getProfile();
1457 std::vector<std::string> MEDFileFieldPerMeshPerType::getLocsReallyUsedMulti() const
1459 std::vector<std::string> ret;
1460 for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1462 std::string tmp=(*it1)->getLocalization();
1463 if(!tmp.empty() && tmp!=MED_GAUSS_ELNO)
1469 void MEDFileFieldPerMeshPerType::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
1471 for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1472 (*it1)->changePflsRefsNamesGen(mapOfModif);
1475 void MEDFileFieldPerMeshPerType::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
1477 for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1478 (*it1)->changeLocsRefsNamesGen(mapOfModif);
1481 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerType::getLeafGivenLocId(int locId)
1483 if(_field_pm_pt_pd.empty())
1485 const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1486 std::ostringstream oss; oss << "MEDFileFieldPerMeshPerType::getLeafGivenLocId : no localizations for geotype \"" << cm.getRepr() << "\" !";
1487 throw INTERP_KERNEL::Exception(oss.str());
1489 if(locId>=0 && locId<(int)_field_pm_pt_pd.size())
1490 return _field_pm_pt_pd[locId];
1491 const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1492 std::ostringstream oss2; oss2 << "MEDFileFieldPerMeshPerType::getLeafGivenLocId : no such locId available (" << locId;
1493 oss2 << ") for geometric type \"" << cm.getRepr() << "\" It should be in [0," << _field_pm_pt_pd.size() << ") !";
1494 throw INTERP_KERNEL::Exception(oss2.str().c_str());
1495 return static_cast<MEDFileFieldPerMeshPerTypePerDisc*>(0);
1498 const MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerType::getLeafGivenLocId(int locId) const
1500 if(_field_pm_pt_pd.empty())
1502 const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1503 std::ostringstream oss; oss << "MEDFileFieldPerMeshPerType::getLeafGivenLocId : no localizations for geotype \"" << cm.getRepr() << "\" !";
1504 throw INTERP_KERNEL::Exception(oss.str());
1506 if(locId>=0 && locId<(int)_field_pm_pt_pd.size())
1507 return _field_pm_pt_pd[locId];
1508 const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1509 std::ostringstream oss2; oss2 << "MEDFileFieldPerMeshPerType::getLeafGivenLocId : no such locId available (" << locId;
1510 oss2 << ") for geometric type \"" << cm.getRepr() << "\" It should be in [0," << _field_pm_pt_pd.size() << ") !";
1511 throw INTERP_KERNEL::Exception(oss2.str().c_str());
1512 return static_cast<const MEDFileFieldPerMeshPerTypePerDisc*>(0);
1515 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
1517 if(_geo_type!=INTERP_KERNEL::NORM_ERROR)
1519 const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1520 if(meshDim!=(int)cm.getDimension())
1523 for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1524 (*it)->getFieldAtLevel(type,glob,dads,pfls,locs,geoTypes);
1527 void MEDFileFieldPerMeshPerType::fillValues(int& startEntryId, std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
1530 for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++,i++)
1532 (*it)->fillValues(i,startEntryId,entries);
1536 void MEDFileFieldPerMeshPerType::setLeaves(const std::vector< MCAuto< MEDFileFieldPerMeshPerTypePerDisc > >& leaves)
1538 _field_pm_pt_pd=leaves;
1539 for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1540 (*it)->setFather(this);
1544 * \param [in,out] globalNum a global numbering counter for the renumbering.
1545 * \param [out] its - list of pair (start,stop) kept
1546 * \return bool - false if the type of field \a tof is not contained in \a this.
1548 bool MEDFileFieldPerMeshPerType::keepOnlySpatialDiscretization(TypeOfField tof, int &globalNum, std::vector< std::pair<int,int> >& its)
1551 std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> > newPmPtPd;
1552 for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1553 if((*it)->getType()==tof)
1555 newPmPtPd.push_back(*it);
1556 std::pair<int,int> bgEnd; bgEnd.first=(*it)->getStart(); bgEnd.second=(*it)->getEnd();
1557 (*it)->setNewStart(globalNum);
1558 globalNum=(*it)->getEnd();
1559 its.push_back(bgEnd);
1563 _field_pm_pt_pd=newPmPtPd;
1568 * \param [in,out] globalNum a global numbering counter for the renumbering.
1569 * \param [out] its - list of pair (start,stop) kept
1570 * \return bool - false if the type of field \a tof is not contained in \a this.
1572 bool MEDFileFieldPerMeshPerType::keepOnlyGaussDiscretization(std::size_t idOfDisc, int &globalNum, std::vector< std::pair<int,int> >& its)
1574 if(_field_pm_pt_pd.size()<=idOfDisc)
1576 MCAuto<MEDFileFieldPerMeshPerTypePerDisc> elt(_field_pm_pt_pd[idOfDisc]);
1577 std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> > newPmPtPd(1,elt);
1578 std::pair<int,int> bgEnd; bgEnd.first=_field_pm_pt_pd[idOfDisc]->getStart(); bgEnd.second=_field_pm_pt_pd[idOfDisc]->getEnd();
1579 elt->setNewStart(globalNum);
1580 globalNum=elt->getEnd();
1581 its.push_back(bgEnd);
1582 _field_pm_pt_pd=newPmPtPd;
1586 MEDFileFieldPerMeshPerType::MEDFileFieldPerMeshPerType(med_idt fid, MEDFileFieldPerMesh *fath, TypeOfField type, INTERP_KERNEL::NormalizedCellType geoType, const MEDFileFieldNameScope& nasc, const PartDefinition *pd):_father(fath),_geo_type(geoType)
1588 INTERP_KERNEL::AutoPtr<char> pflName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
1589 INTERP_KERNEL::AutoPtr<char> locName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
1590 med_geometry_type mgeoti;
1591 med_entity_type menti(ConvertIntoMEDFileType(type,geoType,mgeoti));
1592 int nbProfiles(MEDfieldnProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),menti,mgeoti,pflName,locName));
1593 _field_pm_pt_pd.resize(nbProfiles);
1594 for(int i=0;i<nbProfiles;i++)
1596 _field_pm_pt_pd[i]=MEDFileFieldPerMeshPerTypePerDisc::NewOnRead(this,type,i,pd);
1600 int nbProfiles2(MEDfieldnProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_NODE_ELEMENT,mgeoti,pflName,locName));
1601 for(int i=0;i<nbProfiles2;i++)
1602 _field_pm_pt_pd.push_back(MEDFileFieldPerMeshPerTypePerDisc::NewOnRead(this,ON_GAUSS_NE,i,pd));
1606 void MEDFileFieldPerMeshPerType::loadOnlyStructureOfDataRecursively(med_idt fid, int &start, const MEDFileFieldNameScope& nasc)
1608 for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1609 (*it)->loadOnlyStructureOfDataRecursively(fid,start,nasc);
1612 void MEDFileFieldPerMeshPerType::loadBigArraysRecursively(med_idt fid, const MEDFileFieldNameScope& nasc)
1614 for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1615 (*it)->loadBigArray(fid,nasc);
1618 void MEDFileFieldPerMeshPerType::writeLL(med_idt fid, const MEDFileFieldNameScope& nasc) const
1620 for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1622 (*it)->copyOptionsFrom(*this);
1623 (*it)->writeLL(fid,nasc);
1627 med_entity_type MEDFileFieldPerMeshPerType::ConvertIntoMEDFileType(TypeOfField ikType, INTERP_KERNEL::NormalizedCellType ikGeoType, med_geometry_type& medfGeoType)
1632 medfGeoType=typmai3[(int)ikGeoType];
1635 medfGeoType=MED_NONE;
1638 medfGeoType=typmai3[(int)ikGeoType];
1639 return MED_NODE_ELEMENT;
1641 medfGeoType=typmai3[(int)ikGeoType];
1644 throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerType::ConvertIntoMEDFileType : unexpected entity type ! internal error");
1646 return MED_UNDEF_ENTITY_TYPE;
1649 MEDFileFieldPerMesh *MEDFileFieldPerMesh::NewOnRead(med_idt fid, MEDFileAnyTypeField1TSWithoutSDA *fath, int meshCsit, int meshIteration, int meshOrder, const MEDFileFieldNameScope& nasc, const MEDFileMesh *mm, const std::vector< std::pair<TypeOfField,INTERP_KERNEL::NormalizedCellType> > *entities)
1651 return new MEDFileFieldPerMesh(fid,fath,meshCsit,meshIteration,meshOrder,nasc,mm,entities);
1654 MEDFileFieldPerMesh *MEDFileFieldPerMesh::New(MEDFileAnyTypeField1TSWithoutSDA *fath, const MEDCouplingMesh *mesh)
1656 return new MEDFileFieldPerMesh(fath,mesh);
1659 std::size_t MEDFileFieldPerMesh::getHeapMemorySizeWithoutChildren() const
1661 return _mesh_name.capacity()+_field_pm_pt.capacity()*sizeof(MCAuto< MEDFileFieldPerMeshPerType >);
1664 std::vector<const BigMemoryObject *> MEDFileFieldPerMesh::getDirectChildrenWithNull() const
1666 std::vector<const BigMemoryObject *> ret;
1667 for(std::vector< MCAuto< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1668 ret.push_back((const MEDFileFieldPerMeshPerType *)*it);
1672 MEDFileFieldPerMesh *MEDFileFieldPerMesh::deepCopy(MEDFileAnyTypeField1TSWithoutSDA *father) const
1674 MCAuto< MEDFileFieldPerMesh > ret=new MEDFileFieldPerMesh(*this);
1675 ret->_father=father;
1677 for(std::vector< MCAuto< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++,i++)
1679 if((const MEDFileFieldPerMeshPerType *)*it)
1680 ret->_field_pm_pt[i]=(*it)->deepCopy((MEDFileFieldPerMesh *)(ret));
1685 void MEDFileFieldPerMesh::simpleRepr(int bkOffset, std::ostream& oss, int id) const
1687 std::string startLine(bkOffset,' ');
1688 oss << startLine << "## Field part (" << id << ") lying on mesh \"" << _mesh_name << "\", Mesh iteration=" << _mesh_iteration << ". Mesh order=" << _mesh_order << "." << std::endl;
1689 oss << startLine << "## Field is defined on " << _field_pm_pt.size() << " types." << std::endl;
1691 for(std::vector< MCAuto< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++,i++)
1693 const MEDFileFieldPerMeshPerType *cur=*it;
1695 cur->simpleRepr(bkOffset,oss,i);
1698 oss << startLine << " ## Entry geometry type #" << i << " is empty !" << std::endl;
1703 void MEDFileFieldPerMesh::copyTinyInfoFrom(const MEDCouplingMesh *mesh)
1705 _mesh_name=mesh->getName();
1706 mesh->getTime(_mesh_iteration,_mesh_order);
1709 void MEDFileFieldPerMesh::assignFieldNoProfileNoRenum(int& start, const std::vector<int>& code, const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc)
1711 int nbOfTypes=code.size()/3;
1713 for(int i=0;i<nbOfTypes;i++)
1715 INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)code[3*i];
1716 int nbOfCells=code[3*i+1];
1717 int pos=addNewEntryIfNecessary(type);
1718 _field_pm_pt[pos]->assignFieldNoProfile(start,offset,nbOfCells,field,arr,glob,nasc);
1724 * This method is the most general one. No optimization is done here.
1725 * \param [in] multiTypePfl is the end user profile specified in high level API
1726 * \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].
1727 * \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.
1728 * \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.
1729 * \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.
1730 * \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.
1732 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 DataArray *arr, const MEDCouplingMesh *mesh, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc)
1734 int nbOfTypes(code.size()/3);
1735 for(int i=0;i<nbOfTypes;i++)
1737 INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)code[3*i];
1738 int pos=addNewEntryIfNecessary(type);
1739 DataArrayInt *pfl=0;
1741 pfl=idsPerType[code[3*i+2]];
1742 int nbOfTupes2=code2.size()/3;
1744 for(;found<nbOfTupes2;found++)
1745 if(code[3*i]==code2[3*found])
1747 if(found==nbOfTupes2)
1748 throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::assignFieldProfile : internal problem ! Should never happen ! Please report bug to anthony.geay@cea.fr !");
1749 _field_pm_pt[pos]->assignFieldProfile(nbOfTypes==1,start,multiTypePfl,idsInPflPerType[i],pfl,code2[3*found+1],field,arr,mesh,glob,nasc);
1753 void MEDFileFieldPerMesh::assignNodeFieldNoProfile(int& start, const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob)
1755 int pos=addNewEntryIfNecessary(INTERP_KERNEL::NORM_ERROR);
1756 _field_pm_pt[pos]->assignNodeFieldNoProfile(start,field,arr,glob);
1759 void MEDFileFieldPerMesh::assignNodeFieldProfile(int& start, const DataArrayInt *pfl, const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc)
1761 int pos=addNewEntryIfNecessary(INTERP_KERNEL::NORM_ERROR);
1762 _field_pm_pt[pos]->assignNodeFieldProfile(start,pfl,field,arr,glob,nasc);
1765 void MEDFileFieldPerMesh::loadOnlyStructureOfDataRecursively(med_idt fid, int& start, const MEDFileFieldNameScope& nasc)
1767 for(std::vector< MCAuto< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1768 (*it)->loadOnlyStructureOfDataRecursively(fid,start,nasc);
1771 void MEDFileFieldPerMesh::loadBigArraysRecursively(med_idt fid, const MEDFileFieldNameScope& nasc)
1773 for(std::vector< MCAuto< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1774 (*it)->loadBigArraysRecursively(fid,nasc);
1777 void MEDFileFieldPerMesh::writeLL(med_idt fid, const MEDFileFieldNameScope& nasc) const
1779 int nbOfTypes=_field_pm_pt.size();
1780 for(int i=0;i<nbOfTypes;i++)
1782 _field_pm_pt[i]->copyOptionsFrom(*this);
1783 _field_pm_pt[i]->writeLL(fid,nasc);
1787 void MEDFileFieldPerMesh::getDimension(int& dim) const
1789 for(std::vector< MCAuto< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1790 (*it)->getDimension(dim);
1793 bool MEDFileFieldPerMesh::isUniqueLevel(int& dim) const
1795 for(std::vector< MCAuto< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1796 if(!(*it)->isUniqueLevel(dim))
1801 void MEDFileFieldPerMesh::fillTypesOfFieldAvailable(std::set<TypeOfField>& types) const
1803 for(std::vector< MCAuto< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1804 (*it)->fillTypesOfFieldAvailable(types);
1807 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
1809 int sz=_field_pm_pt.size();
1810 std::vector< std::vector<std::pair<int,int> > > ret(sz);
1811 types.resize(sz); typesF.resize(sz); pfls.resize(sz); locs.resize(sz);
1812 for(int i=0;i<sz;i++)
1814 types[i]=_field_pm_pt[i]->getGeoType();
1815 _field_pm_pt[i]->fillFieldSplitedByType(ret[i],typesF[i],pfls[i],locs[i]);
1820 double MEDFileFieldPerMesh::getTime() const
1823 return _father->getTime(tmp1,tmp2);
1826 int MEDFileFieldPerMesh::getIteration() const
1828 return _father->getIteration();
1831 int MEDFileFieldPerMesh::getOrder() const
1833 return _father->getOrder();
1836 int MEDFileFieldPerMesh::getNumberOfComponents() const
1838 return _father->getNumberOfComponents();
1841 bool MEDFileFieldPerMesh::presenceOfMultiDiscPerGeoType() const
1843 for(std::vector< MCAuto< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1845 const MEDFileFieldPerMeshPerType *fpmt(*it);
1848 if(fpmt->presenceOfMultiDiscPerGeoType())
1854 DataArray *MEDFileFieldPerMesh::getOrCreateAndGetArray()
1857 throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getOrCreateAndGetArray : no father ! internal error !");
1858 return _father->getOrCreateAndGetArray();
1861 const DataArray *MEDFileFieldPerMesh::getOrCreateAndGetArray() const
1864 throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getOrCreateAndGetArray : no father ! internal error !");
1865 return _father->getOrCreateAndGetArray();
1868 const std::vector<std::string>& MEDFileFieldPerMesh::getInfo() const
1870 return _father->getInfo();
1874 * type,geoTypes,dads,pfls,locs are input parameters. They should have the same size.
1875 * 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.
1876 * It returns 2 output vectors :
1877 * - 'code' of size 3*sz where sz is the number of different values into 'geoTypes'
1878 * - 'notNullPfls' contains sz2 values that are extracted from 'pfls' in which null profiles have been removed.
1879 * 'code' and 'notNullPfls' are in MEDCouplingUMesh::checkTypeConsistencyAndContig format.
1881 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)
1883 int notNullPflsSz=0;
1884 int nbOfArrs=geoTypes.size();
1885 for(int i=0;i<nbOfArrs;i++)
1888 std::set<INTERP_KERNEL::NormalizedCellType> geoTypes3(geoTypes.begin(),geoTypes.end());
1889 int nbOfDiffGeoTypes=geoTypes3.size();
1890 code.resize(3*nbOfDiffGeoTypes);
1891 notNullPfls.resize(notNullPflsSz);
1894 for(int i=0;i<nbOfDiffGeoTypes;i++)
1897 INTERP_KERNEL::NormalizedCellType refType=geoTypes[j];
1898 std::vector<const DataArrayInt *> notNullTmp;
1900 notNullTmp.push_back(pfls[j]);
1902 for(;j<nbOfArrs;j++)
1903 if(geoTypes[j]==refType)
1906 notNullTmp.push_back(pfls[j]);
1910 std::vector< std::pair<int,int> > tmpDads(dads.begin()+startZone,dads.begin()+j);
1911 std::vector<const DataArrayInt *> tmpPfls(pfls.begin()+startZone,pfls.begin()+j);
1912 std::vector<int> tmpLocs(locs.begin()+startZone,locs.begin()+j);
1913 code[3*i]=(int)refType;
1914 std::vector<INTERP_KERNEL::NormalizedCellType> refType2(1,refType);
1915 code[3*i+1]=ComputeNbOfElems(glob,type,refType2,tmpDads,tmpLocs);
1916 if(notNullTmp.empty())
1920 notNullPfls[notNullPflsSz]=DataArrayInt::Aggregate(notNullTmp);
1921 code[3*i+2]=notNullPflsSz++;
1927 * 'dads' 'geoTypes' and 'locs' are input parameters that should have same size sz. sz should be >=1.
1929 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)
1933 for(int i=0;i<sz;i++)
1937 if(type!=ON_GAUSS_NE)
1938 ret+=dads[i].second-dads[i].first;
1941 const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(geoTypes[i]);
1942 ret+=(dads[i].second-dads[i].first)/cm.getNumberOfNodes();
1947 int nbOfGaussPtPerCell=glob->getNbOfGaussPtPerCell(locs[i]);
1948 ret+=(dads[i].second-dads[i].first)/nbOfGaussPtPerCell;
1954 std::vector<std::string> MEDFileFieldPerMesh::getPflsReallyUsed() const
1956 std::vector<std::string> ret;
1957 std::set<std::string> ret2;
1958 for(std::vector< MCAuto< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1960 std::vector<std::string> tmp=(*it)->getPflsReallyUsed();
1961 for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
1962 if(ret2.find(*it2)==ret2.end())
1964 ret.push_back(*it2);
1971 std::vector<std::string> MEDFileFieldPerMesh::getPflsReallyUsedMulti() const
1973 std::vector<std::string> ret;
1974 for(std::vector< MCAuto< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1976 std::vector<std::string> tmp=(*it)->getPflsReallyUsedMulti();
1977 ret.insert(ret.end(),tmp.begin(),tmp.end());
1982 std::vector<std::string> MEDFileFieldPerMesh::getLocsReallyUsed() const
1984 std::vector<std::string> ret;
1985 std::set<std::string> ret2;
1986 for(std::vector< MCAuto< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1988 std::vector<std::string> tmp=(*it)->getLocsReallyUsed();
1989 for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
1990 if(ret2.find(*it2)==ret2.end())
1992 ret.push_back(*it2);
1999 std::vector<std::string> MEDFileFieldPerMesh::getLocsReallyUsedMulti() const
2001 std::vector<std::string> ret;
2002 for(std::vector< MCAuto< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2004 std::vector<std::string> tmp=(*it)->getLocsReallyUsedMulti();
2005 ret.insert(ret.end(),tmp.begin(),tmp.end());
2010 bool MEDFileFieldPerMesh::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab)
2012 for(std::vector< std::pair<std::string,std::string> >::const_iterator it=modifTab.begin();it!=modifTab.end();it++)
2014 if((*it).first==_mesh_name)
2016 _mesh_name=(*it).second;
2023 bool MEDFileFieldPerMesh::renumberEntitiesLyingOnMesh(const std::string& meshName, const std::vector<int>& oldCode, const std::vector<int>& newCode, const DataArrayInt *renumO2N,
2024 MEDFileFieldGlobsReal& glob)
2026 if(_mesh_name!=meshName)
2028 std::set<INTERP_KERNEL::NormalizedCellType> typesToKeep;
2029 for(std::size_t i=0;i<oldCode.size()/3;i++) typesToKeep.insert((INTERP_KERNEL::NormalizedCellType)oldCode[3*i]);
2030 std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > > entries;
2031 std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> entriesKept;
2032 std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> otherEntries;
2033 getUndergroundDataArrayExt(entries);
2034 DataArray *arr0(getOrCreateAndGetArray());//tony
2036 throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::renumberEntitiesLyingOnMesh : DataArray storing values of field is null !");
2037 DataArrayDouble *arr(dynamic_cast<DataArrayDouble *>(arr0));//tony
2039 throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::renumberEntitiesLyingOnMesh : DataArray storing values is double ! Not managed for the moment !");
2042 throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::renumberEntitiesLyingOnMesh : DataArrayDouble storing values of field is null !");
2043 for(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >::const_iterator it=entries.begin();it!=entries.end();it++)
2045 if(typesToKeep.find((*it).first.first)!=typesToKeep.end())
2047 entriesKept.push_back(getLeafGivenTypeAndLocId((*it).first.first,(*it).first.second));
2048 sz+=(*it).second.second-(*it).second.first;
2051 otherEntries.push_back(getLeafGivenTypeAndLocId((*it).first.first,(*it).first.second));
2053 MCAuto<DataArrayInt> renumDefrag=DataArrayInt::New(); renumDefrag->alloc(arr->getNumberOfTuples(),1); renumDefrag->fillWithZero();
2054 ////////////////////
2055 MCAuto<DataArrayInt> explicitIdsOldInMesh=DataArrayInt::New(); explicitIdsOldInMesh->alloc(sz,1);//sz is a majorant of the real size. A realloc will be done after
2056 int *workI2=explicitIdsOldInMesh->getPointer();
2057 int sz1=0,sz2=0,sid=1;
2058 std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> > entriesKeptML=MEDFileFieldPerMeshPerTypePerDisc::SplitPerDiscretization(entriesKept);
2059 // std::vector<int> tupleIdOfStartOfNewChuncksV(entriesKeptML.size());
2060 for(std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> >::const_iterator itL1=entriesKeptML.begin();itL1!=entriesKeptML.end();itL1++,sid++)
2062 // tupleIdOfStartOfNewChuncksV[sid-1]=sz2;
2063 MCAuto<DataArrayInt> explicitIdsOldInArr=DataArrayInt::New(); explicitIdsOldInArr->alloc(sz,1);
2064 int *workI=explicitIdsOldInArr->getPointer();
2065 for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator itL2=(*itL1).begin();itL2!=(*itL1).end();itL2++)
2067 int delta1=(*itL2)->fillTupleIds(workI); workI+=delta1; sz1+=delta1;
2068 (*itL2)->setLocId(sz2);
2069 (*itL2)->_tmp_work1=(*itL2)->getStart();
2070 int delta2=(*itL2)->fillEltIdsFromCode(sz2,oldCode,glob,workI2); workI2+=delta2; sz2+=delta2;
2072 renumDefrag->setPartOfValuesSimple3(sid,explicitIdsOldInArr->begin(),explicitIdsOldInArr->end(),0,1,1);
2074 explicitIdsOldInMesh->reAlloc(sz2);
2075 int tupleIdOfStartOfNewChuncks=arr->getNumberOfTuples()-sz2;
2076 ////////////////////
2077 MCAuto<DataArrayInt> permArrDefrag=renumDefrag->buildPermArrPerLevel(); renumDefrag=0;
2078 // perform redispatching of non concerned MEDFileFieldPerMeshPerTypePerDisc
2079 std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> > otherEntriesNew;
2080 for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=otherEntries.begin();it!=otherEntries.end();it++)
2082 otherEntriesNew.push_back(MEDFileFieldPerMeshPerTypePerDisc::New(*(*it)));
2083 otherEntriesNew.back()->setNewStart(permArrDefrag->getIJ((*it)->getStart(),0));
2084 otherEntriesNew.back()->setLocId((*it)->getGeoType());
2086 std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> > entriesKeptNew;
2087 std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> entriesKeptNew2;
2088 for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=entriesKept.begin();it!=entriesKept.end();it++)
2090 MCAuto<MEDFileFieldPerMeshPerTypePerDisc> elt=MEDFileFieldPerMeshPerTypePerDisc::New(*(*it));
2091 int newStart=elt->getLocId();
2092 elt->setLocId((*it)->getGeoType());
2093 elt->setNewStart(newStart);
2094 elt->_tmp_work1=permArrDefrag->getIJ(elt->_tmp_work1,0);
2095 entriesKeptNew.push_back(elt);
2096 entriesKeptNew2.push_back(elt);
2098 MCAuto<DataArrayDouble> arr2=arr->renumber(permArrDefrag->getConstPointer());
2099 // perform redispatching of concerned MEDFileFieldPerMeshPerTypePerDisc -> values are in arr2
2100 MCAuto<DataArrayInt> explicitIdsNewInMesh=renumO2N->selectByTupleId(explicitIdsOldInMesh->begin(),explicitIdsOldInMesh->end());
2101 std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> > entriesKeptPerDisc=MEDFileFieldPerMeshPerTypePerDisc::SplitPerDiscretization(entriesKeptNew2);
2103 for(std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> >::const_iterator it4=entriesKeptPerDisc.begin();it4!=entriesKeptPerDisc.end();it4++)
2106 /*for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator itL2=(*it4).begin();itL2!=(*it4).end();itL2++)
2108 MEDFileFieldPerMeshPerTypePerDisc *curNC=const_cast<MEDFileFieldPerMeshPerTypePerDisc *>(*itL2);
2109 curNC->setNewStart(permArrDefrag->getIJ((*itL2)->getStart(),0)-tupleIdOfStartOfNewChuncks+tupleIdOfStartOfNewChuncksV[sid]);
2111 ret=MEDFileFieldPerMeshPerTypePerDisc::RenumberChunks(tupleIdOfStartOfNewChuncks,*it4,explicitIdsNewInMesh,newCode,
2112 glob,arr2,otherEntriesNew) || ret;
2116 // Assign new dispatching
2117 assignNewLeaves(otherEntriesNew);
2118 arr->deepCopyFrom(*arr2);
2123 * \param [in,out] globalNum a global numbering counter for the renumbering.
2124 * \param [out] its - list of pair (start,stop) kept
2126 void MEDFileFieldPerMesh::keepOnlySpatialDiscretization(TypeOfField tof, int &globalNum, std::vector< std::pair<int,int> >& its)
2128 std::vector< MCAuto< MEDFileFieldPerMeshPerType > > ret;
2129 for(std::vector< MCAuto< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2131 std::vector< std::pair<int,int> > its2;
2132 if((*it)->keepOnlySpatialDiscretization(tof,globalNum,its2))
2135 its.insert(its.end(),its2.begin(),its2.end());
2142 * \param [in,out] globalNum a global numbering counter for the renumbering.
2143 * \param [out] its - list of pair (start,stop) kept
2145 void MEDFileFieldPerMesh::keepOnlyGaussDiscretization(std::size_t idOfDisc, int &globalNum, std::vector< std::pair<int,int> >& its)
2147 std::vector< MCAuto< MEDFileFieldPerMeshPerType > > ret;
2148 for(std::vector< MCAuto< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2150 std::vector< std::pair<int,int> > its2;
2151 if((*it)->keepOnlyGaussDiscretization(idOfDisc,globalNum,its2))
2154 its.insert(its.end(),its2.begin(),its2.end());
2160 void MEDFileFieldPerMesh::assignNewLeaves(const std::vector< MCAuto< MEDFileFieldPerMeshPerTypePerDisc > >& leaves)
2162 std::map<INTERP_KERNEL::NormalizedCellType,std::vector< MCAuto< MEDFileFieldPerMeshPerTypePerDisc> > > types;
2163 for( std::vector< MCAuto< MEDFileFieldPerMeshPerTypePerDisc > >::const_iterator it=leaves.begin();it!=leaves.end();it++)
2164 types[(INTERP_KERNEL::NormalizedCellType)(*it)->getLocId()].push_back(*it);
2166 std::vector< MCAuto< MEDFileFieldPerMeshPerType > > fieldPmPt(types.size());
2167 std::map<INTERP_KERNEL::NormalizedCellType,std::vector< MCAuto< MEDFileFieldPerMeshPerTypePerDisc> > >::const_iterator it1=types.begin();
2168 std::vector< MCAuto< MEDFileFieldPerMeshPerType > >::iterator it2=fieldPmPt.begin();
2169 for(;it1!=types.end();it1++,it2++)
2171 MCAuto<MEDFileFieldPerMeshPerType> elt=MEDFileFieldPerMeshPerType::New(this,(INTERP_KERNEL::NormalizedCellType)((*it1).second[0]->getLocId()));
2172 elt->setLeaves((*it1).second);
2175 _field_pm_pt=fieldPmPt;
2178 void MEDFileFieldPerMesh::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
2180 for(std::vector< MCAuto< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2181 (*it)->changePflsRefsNamesGen(mapOfModif);
2184 void MEDFileFieldPerMesh::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
2186 for(std::vector< MCAuto< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2187 (*it)->changeLocsRefsNamesGen(mapOfModif);
2191 * \param [in] mesh is the whole mesh
2193 MEDCouplingFieldDouble *MEDFileFieldPerMesh::getFieldOnMeshAtLevel(TypeOfField type, const MEDFileFieldGlobsReal *glob, const MEDCouplingMesh *mesh, bool& isPfl, MCAuto<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const
2195 if(_field_pm_pt.empty())
2196 throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getFieldOnMeshAtLevel : no types field set !");
2198 std::vector< std::pair<int,int> > dads;
2199 std::vector<const DataArrayInt *> pfls;
2200 std::vector<DataArrayInt *> notNullPflsPerGeoType;
2201 std::vector<int> locs,code;
2202 std::vector<INTERP_KERNEL::NormalizedCellType> geoTypes;
2203 for(std::vector< MCAuto< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2204 (*it)->getFieldAtLevel(mesh->getMeshDimension(),type,glob,dads,pfls,locs,geoTypes);
2206 SortArraysPerType(glob,type,geoTypes,dads,pfls,locs,code,notNullPflsPerGeoType);
2209 std::ostringstream oss; oss << "MEDFileFieldPerMesh::getFieldOnMeshAtLevel : " << "The field \"" << nasc.getName() << "\" exists but not with such spatial discretization or such dimension specified !";
2210 throw INTERP_KERNEL::Exception(oss.str());
2213 std::vector< MCAuto<DataArrayInt> > notNullPflsPerGeoType2(notNullPflsPerGeoType.begin(),notNullPflsPerGeoType.end());
2214 std::vector< const DataArrayInt *> notNullPflsPerGeoType3(notNullPflsPerGeoType.begin(),notNullPflsPerGeoType.end());
2217 DataArrayInt *arr=mesh->checkTypeConsistencyAndContig(code,notNullPflsPerGeoType3);
2219 return finishField(type,glob,dads,locs,mesh,isPfl,arrOut,nasc);
2222 MCAuto<DataArrayInt> arr2(arr);
2223 return finishField2(type,glob,dads,locs,geoTypes,mesh,arr,isPfl,arrOut,nasc);
2229 throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getFieldOnMeshAtLevel : internal error #1 !");
2233 if(nb!=mesh->getNumberOfNodes())
2235 std::ostringstream oss; oss << "MEDFileFieldPerMesh::getFieldOnMeshAtLevel : There is a problem there is " << nb << " nodes in field whereas there is " << mesh->getNumberOfNodes();
2236 oss << " nodes in mesh !";
2237 throw INTERP_KERNEL::Exception(oss.str());
2239 return finishField(type,glob,dads,locs,mesh,isPfl,arrOut,nasc);
2242 return finishFieldNode2(glob,dads,locs,mesh,notNullPflsPerGeoType3[0],isPfl,arrOut,nasc);
2246 DataArray *MEDFileFieldPerMesh::getFieldOnMeshAtLevelWithPfl(TypeOfField type, const MEDCouplingMesh *mesh, DataArrayInt *&pfl, const MEDFileFieldGlobsReal *glob, const MEDFileFieldNameScope& nasc) const
2248 if(_field_pm_pt.empty())
2249 throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getFieldOnMeshAtLevel : no types field set !");
2251 std::vector<std::pair<int,int> > dads;
2252 std::vector<const DataArrayInt *> pfls;
2253 std::vector<DataArrayInt *> notNullPflsPerGeoType;
2254 std::vector<int> locs,code;
2255 std::vector<INTERP_KERNEL::NormalizedCellType> geoTypes;
2256 for(std::vector< MCAuto< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2257 (*it)->getFieldAtLevel(mesh->getMeshDimension(),type,glob,dads,pfls,locs,geoTypes);
2259 SortArraysPerType(glob,type,geoTypes,dads,pfls,locs,code,notNullPflsPerGeoType);
2262 std::ostringstream oss; oss << "MEDFileFieldPerMesh::getFieldOnMeshAtLevelWithPfl : " << "The field \"" << nasc.getName() << "\" exists but not with such spatial discretization or such dimension specified !";
2263 throw INTERP_KERNEL::Exception(oss.str());
2265 std::vector< MCAuto<DataArrayInt> > notNullPflsPerGeoType2(notNullPflsPerGeoType.begin(),notNullPflsPerGeoType.end());
2266 std::vector< const DataArrayInt *> notNullPflsPerGeoType3(notNullPflsPerGeoType.begin(),notNullPflsPerGeoType.end());
2269 MCAuto<DataArrayInt> arr=mesh->checkTypeConsistencyAndContig(code,notNullPflsPerGeoType3);
2270 return finishField4(dads,arr,mesh->getNumberOfCells(),pfl);
2275 throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getFieldOnMeshAtLevel : internal error #1 !");
2279 if(nb!=mesh->getNumberOfNodes())
2281 std::ostringstream oss; oss << "MEDFileFieldPerMesh::getFieldOnMeshAtLevel : There is a problem there is " << nb << " nodes in field whereas there is " << mesh->getNumberOfNodes();
2282 oss << " nodes in mesh !";
2283 throw INTERP_KERNEL::Exception(oss.str());
2286 return finishField4(dads,code[2]==-1?0:notNullPflsPerGeoType3[0],mesh->getNumberOfNodes(),pfl);
2292 void MEDFileFieldPerMesh::getUndergroundDataArrayExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
2296 for(std::vector< MCAuto< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2298 (*it)->getSizes(globalSz,nbOfEntries);
2300 entries.resize(nbOfEntries);
2302 for(std::vector< MCAuto< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2304 (*it)->fillValues(nbOfEntries,entries);
2308 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMesh::getLeafGivenTypeAndLocId(INTERP_KERNEL::NormalizedCellType typ, int locId)
2310 for(std::vector< MCAuto< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2312 if((*it)->getGeoType()==typ)
2313 return (*it)->getLeafGivenLocId(locId);
2315 const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(typ);
2316 std::ostringstream oss; oss << "MEDFileFieldPerMesh::getLeafGivenTypeAndLocId : no such geometric type \"" << cm.getRepr() << "\" in this !" << std::endl;
2317 oss << "Possiblities are : ";
2318 for(std::vector< MCAuto< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2320 const INTERP_KERNEL::CellModel& cm2=INTERP_KERNEL::CellModel::GetCellModel((*it)->getGeoType());
2321 oss << "\"" << cm2.getRepr() << "\", ";
2323 throw INTERP_KERNEL::Exception(oss.str());
2326 const MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMesh::getLeafGivenTypeAndLocId(INTERP_KERNEL::NormalizedCellType typ, int locId) const
2328 for(std::vector< MCAuto< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2330 if((*it)->getGeoType()==typ)
2331 return (*it)->getLeafGivenLocId(locId);
2333 const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(typ);
2334 std::ostringstream oss; oss << "MEDFileFieldPerMesh::getLeafGivenTypeAndLocId : no such geometric type \"" << cm.getRepr() << "\" in this !" << std::endl;
2335 oss << "Possiblities are : ";
2336 for(std::vector< MCAuto< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2338 const INTERP_KERNEL::CellModel& cm2=INTERP_KERNEL::CellModel::GetCellModel((*it)->getGeoType());
2339 oss << "\"" << cm2.getRepr() << "\", ";
2341 throw INTERP_KERNEL::Exception(oss.str());
2345 * \param [in,out] start - Integer that gives the current position in the final aggregated array
2346 * \param [in] pms - list of elements to aggregate. integer gives the mesh id
2347 * \param [in] dts - (Distribution of types) = level 1 : meshes to aggregate. Level 2 : all geo type. Level 3 pair specifying geo type and number of elem in geotype.
2348 * \param [out] extractInfo - Gives information about the where the data comes from. It is a vector of triplet. First element in the triplet the mesh pos. The 2nd one the start pos. The 3rd the end pos.
2350 MCAuto<MEDFileFieldPerMeshPerTypePerDisc> MEDFileFieldPerMeshPerTypePerDisc::Aggregate(int &start, const std::vector< std::pair<int,const MEDFileFieldPerMeshPerTypePerDisc *> >& pms, const std::vector< std::vector< std::pair<int,int> > >& dts, TypeOfField tof, MEDFileFieldPerMeshPerType *father, std::vector<std::pair< int, std::pair<int,int> > >& extractInfo)
2352 MCAuto<MEDFileFieldPerMeshPerTypePerDisc> ret(new MEDFileFieldPerMeshPerTypePerDisc(father,tof));
2354 throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::Aggregate : empty input vector !");
2355 for(std::vector<std::pair<int,const MEDFileFieldPerMeshPerTypePerDisc *> >::const_iterator it=pms.begin();it!=pms.end();it++)
2358 throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::Aggregate : presence of null pointer !");
2359 if(!(*it).second->getProfile().empty())
2360 throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::Aggregate : not implemented yet for profiles !");
2361 if(!(*it).second->getLocalization().empty())
2362 throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::Aggregate : not implemented yet for gauss pts !");
2364 INTERP_KERNEL::NormalizedCellType gt(pms[0].second->getGeoType());
2366 std::vector< std::pair<int,int> > filteredDTS;
2367 for(std::vector< std::vector< std::pair<int,int> > >::const_iterator it=dts.begin();it!=dts.end();it++,i++)
2368 for(std::vector< std::pair<int,int> >::const_iterator it2=(*it).begin();it2!=(*it).end();it2++)
2369 if((*it2).first==gt)
2370 filteredDTS.push_back(std::pair<int,int>(i,(*it2).second));
2371 if(pms.size()!=filteredDTS.size())
2372 throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::Aggregate : not implemented yet for generated profiles !");
2373 std::vector<std::pair<int,const MEDFileFieldPerMeshPerTypePerDisc *> >::const_iterator it1(pms.begin());
2374 std::vector< std::pair<int,int> >::const_iterator it2(filteredDTS.begin());
2375 int zeStart(start),nval(0);
2376 for(;it1!=pms.end();it1++,it2++)
2378 if((*it1).first!=(*it2).first)
2379 throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::Aggregate : not implemented yet for generated profiles 2 !");
2380 int s1((*it1).second->getStart()),e1((*it1).second->getEnd());
2381 extractInfo.push_back(std::pair<int, std::pair<int,int> >((*it1).first,std::pair<int,int>(s1,e1)));
2383 nval+=((*it1).second)->getNumberOfVals();
2385 ret->_start=zeStart; ret->_end=start; ret->_nval=nval;
2389 MCAuto<MEDFileFieldPerMeshPerType> MEDFileFieldPerMeshPerType::Aggregate(int &start, const std::vector<std::pair<int,const MEDFileFieldPerMeshPerType *> >& pms, const std::vector< std::vector< std::pair<int,int> > >& dts, INTERP_KERNEL::NormalizedCellType gt, MEDFileFieldPerMesh *father, std::vector<std::pair< int, std::pair<int,int> > >& extractInfo)
2391 MCAuto<MEDFileFieldPerMeshPerType> ret(new MEDFileFieldPerMeshPerType(father,gt));
2392 std::map<TypeOfField, std::vector< std::pair<int,const MEDFileFieldPerMeshPerTypePerDisc * > > > m;
2393 for(std::vector<std::pair<int,const MEDFileFieldPerMeshPerType *> >::const_iterator it=pms.begin();it!=pms.end();it++)
2395 for(std::vector< MCAuto<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it2=(*it).second->_field_pm_pt_pd.begin();it2!=(*it).second->_field_pm_pt_pd.end();it2++)
2396 m[(*it2)->getType()].push_back(std::pair<int,const MEDFileFieldPerMeshPerTypePerDisc * >((*it).first,*it2));
2398 for(std::map<TypeOfField, std::vector< std::pair<int,const MEDFileFieldPerMeshPerTypePerDisc * > > >::const_iterator it=m.begin();it!=m.end();it++)
2400 MCAuto<MEDFileFieldPerMeshPerTypePerDisc> agg(MEDFileFieldPerMeshPerTypePerDisc::Aggregate(start,(*it).second,dts,(*it).first,ret,extractInfo));
2401 ret->_field_pm_pt_pd.push_back(agg);
2406 MCAuto<MEDFileFieldPerMesh> MEDFileFieldPerMesh::Aggregate(int &start, const std::vector<const MEDFileFieldPerMesh *>& pms, const std::vector< std::vector< std::pair<int,int> > >& dts, MEDFileAnyTypeField1TSWithoutSDA *father, std::vector<std::pair< int, std::pair<int,int> > >& extractInfo)
2408 MCAuto<MEDFileFieldPerMesh> ret(new MEDFileFieldPerMesh(father,pms[0]->getMeshName(),pms[0]->getMeshIteration(),pms[0]->getMeshOrder()));
2409 std::map<INTERP_KERNEL::NormalizedCellType, std::vector< std::pair<int,const MEDFileFieldPerMeshPerType *> > > m;
2411 for(std::vector<const MEDFileFieldPerMesh *>::const_iterator it=pms.begin();it!=pms.end();it++,i++)
2413 const std::vector< MCAuto< MEDFileFieldPerMeshPerType > >& v((*it)->_field_pm_pt);
2414 for(std::vector< MCAuto< MEDFileFieldPerMeshPerType > >::const_iterator it2=v.begin();it2!=v.end();it2++)
2416 INTERP_KERNEL::NormalizedCellType gt((*it2)->getGeoType());
2417 m[gt].push_back(std::pair<int,const MEDFileFieldPerMeshPerType *>(i,*it2));
2420 for(std::map<INTERP_KERNEL::NormalizedCellType, std::vector< std::pair<int,const MEDFileFieldPerMeshPerType *> > >::const_iterator it=m.begin();it!=m.end();it++)
2422 MCAuto<MEDFileFieldPerMeshPerType> agg(MEDFileFieldPerMeshPerType::Aggregate(start,(*it).second,dts,(*it).first,ret,extractInfo));
2423 ret->_field_pm_pt.push_back(agg);
2428 int MEDFileFieldPerMesh::addNewEntryIfNecessary(INTERP_KERNEL::NormalizedCellType type)
2431 int pos=std::distance(typmai2,std::find(typmai2,typmai2+MED_N_CELL_FIXED_GEO,type));
2432 std::vector< MCAuto< MEDFileFieldPerMeshPerType > >::iterator it2=_field_pm_pt.begin();
2433 for(std::vector< MCAuto< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++,i++)
2435 INTERP_KERNEL::NormalizedCellType curType=(*it)->getGeoType();
2440 int pos2=std::distance(typmai2,std::find(typmai2,typmai2+MED_N_CELL_FIXED_GEO,curType));
2445 int ret=std::distance(_field_pm_pt.begin(),it2);
2446 _field_pm_pt.insert(it2,MEDFileFieldPerMeshPerType::New(this,type));
2451 * 'dads' and 'locs' input parameters have the same number of elements
2452 * \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
2454 MEDCouplingFieldDouble *MEDFileFieldPerMesh::finishField(TypeOfField type, const MEDFileFieldGlobsReal *glob,
2455 const std::vector< std::pair<int,int> >& dads, const std::vector<int>& locs,
2456 const MEDCouplingMesh *mesh, bool& isPfl, MCAuto<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const
2459 MCAuto<MEDCouplingFieldDouble> ret=MEDCouplingFieldDouble::New(type,ONE_TIME);
2460 ret->setMesh(mesh); ret->setName(nasc.getName().c_str()); ret->setTime(getTime(),getIteration(),getOrder()); ret->setTimeUnit(nasc.getDtUnit().c_str());
2461 MCAuto<DataArray> da=getOrCreateAndGetArray()->selectByTupleRanges(dads);
2462 const std::vector<std::string>& infos=getInfo();
2463 da->setInfoOnComponents(infos);
2465 if(type==ON_GAUSS_PT)
2468 int nbOfArrs=dads.size();
2469 for(int i=0;i<nbOfArrs;i++)
2471 std::vector<std::pair<int,int> > dads2(1,dads[i]); const std::vector<int> locs2(1,locs[i]);
2472 const std::vector<INTERP_KERNEL::NormalizedCellType> geoTypes2(1,INTERP_KERNEL::NORM_ERROR);
2473 int nbOfElems=ComputeNbOfElems(glob,type,geoTypes2,dads2,locs2);
2474 MCAuto<DataArrayInt> di=DataArrayInt::New();
2475 di->alloc(nbOfElems,1);
2477 const MEDFileFieldLoc& fl=glob->getLocalizationFromId(locs[i]);
2478 ret->setGaussLocalizationOnCells(di->getConstPointer(),di->getConstPointer()+nbOfElems,fl.getRefCoords(),fl.getGaussCoords(),fl.getGaussWeights());
2487 * 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.
2488 * 'dads', 'locs' and 'geoTypes' input parameters have the same number of elements.
2489 * No check of this is performed. 'da' array contains an array in old2New style to be applyied to mesh to obtain the right support.
2490 * The order of cells in the returned field is those imposed by the profile.
2491 * \param [in] mesh is the global mesh.
2493 MEDCouplingFieldDouble *MEDFileFieldPerMesh::finishField2(TypeOfField type, const MEDFileFieldGlobsReal *glob,
2494 const std::vector<std::pair<int,int> >& dads, const std::vector<int>& locs,
2495 const std::vector<INTERP_KERNEL::NormalizedCellType>& geoTypes,
2496 const MEDCouplingMesh *mesh, const DataArrayInt *da, bool& isPfl, MCAuto<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const
2498 if(da->isIota(mesh->getNumberOfCells()))
2499 return finishField(type,glob,dads,locs,mesh,isPfl,arrOut,nasc);
2500 MCAuto<MEDCouplingMesh> m2=mesh->buildPart(da->getConstPointer(),da->getConstPointer()+da->getNbOfElems());
2501 m2->setName(mesh->getName().c_str());
2502 MCAuto<MEDCouplingFieldDouble> ret=finishField(type,glob,dads,locs,m2,isPfl,arrOut,nasc);
2508 * This method is the complement of MEDFileFieldPerMesh::finishField2 method except that this method works for node profiles.
2510 MEDCouplingFieldDouble *MEDFileFieldPerMesh::finishFieldNode2(const MEDFileFieldGlobsReal *glob,
2511 const std::vector<std::pair<int,int> >& dads, const std::vector<int>& locs,
2512 const MEDCouplingMesh *mesh, const DataArrayInt *da, bool& isPfl, MCAuto<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const
2514 if(da->isIota(mesh->getNumberOfNodes()))
2515 return finishField(ON_NODES,glob,dads,locs,mesh,isPfl,arrOut,nasc);
2516 // Treatment of particular case where nodal field on pfl is requested with a meshDimRelToMax=1.
2517 const MEDCouplingUMesh *meshu=dynamic_cast<const MEDCouplingUMesh *>(mesh);
2520 if(meshu->getNodalConnectivity()==0)
2522 MCAuto<MEDCouplingFieldDouble> ret=finishField(ON_CELLS,glob,dads,locs,mesh,isPfl,arrOut,nasc);
2523 int nb=da->getNbOfElems();
2524 const int *ptr=da->getConstPointer();
2525 MEDCouplingUMesh *meshuc=const_cast<MEDCouplingUMesh *>(meshu);
2526 meshuc->allocateCells(nb);
2527 for(int i=0;i<nb;i++)
2528 meshuc->insertNextCell(INTERP_KERNEL::NORM_POINT1,1,ptr+i);
2529 meshuc->finishInsertingCells();
2530 ret->setMesh(meshuc);
2531 const MEDCouplingFieldDiscretization *disc=ret->getDiscretization();
2532 if(!disc) throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::finishFieldNode2 : internal error, no discretization on field !");
2533 disc->checkCoherencyBetween(meshuc,arrOut);
2538 MCAuto<MEDCouplingFieldDouble> ret=finishField(ON_NODES,glob,dads,locs,mesh,isPfl,arrOut,nasc);
2540 DataArrayInt *arr2=0;
2541 MCAuto<DataArrayInt> cellIds=mesh->getCellIdsFullyIncludedInNodeIds(da->getConstPointer(),da->getConstPointer()+da->getNbOfElems());
2542 MCAuto<MEDCouplingMesh> mesh2=mesh->buildPartAndReduceNodes(cellIds->getConstPointer(),cellIds->getConstPointer()+cellIds->getNbOfElems(),arr2);
2543 MCAuto<DataArrayInt> arr3(arr2);
2544 int nnodes=mesh2->getNumberOfNodes();
2545 if(nnodes==(int)da->getNbOfElems())
2547 MCAuto<DataArrayInt> da3=da->transformWithIndArrR(arr2->begin(),arr2->end());
2548 arrOut->renumberInPlace(da3->getConstPointer());
2549 mesh2->setName(mesh->getName().c_str());
2550 ret->setMesh(mesh2);
2555 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 !!!";
2556 oss << "So it is impossible to return a well definied MEDCouplingFieldDouble instance on specified mesh on a specified meshDim !" << std::endl;
2557 oss << "To retrieve correctly such a field you have 3 possibilities :" << std::endl;
2558 oss << " - use an another meshDim compatible with the field on nodes (MED file does not have such information)" << std::endl;
2559 oss << " - use an another a meshDimRelToMax equal to 1 -> it will return a mesh with artificial cell POINT1 containing the profile !" << std::endl;
2560 oss << " - if definitely the node profile has no link with mesh connectivity use MEDFileField1TS::getFieldWithProfile or MEDFileFieldMultiTS::getFieldWithProfile methods instead !";
2561 throw INTERP_KERNEL::Exception(oss.str());
2567 * This method is the most light method of field retrieving.
2569 DataArray *MEDFileFieldPerMesh::finishField4(const std::vector<std::pair<int,int> >& dads, const DataArrayInt *pflIn, int nbOfElems, DataArrayInt *&pflOut) const
2573 pflOut=DataArrayInt::New();
2574 pflOut->alloc(nbOfElems,1);
2579 pflOut=const_cast<DataArrayInt*>(pflIn);
2582 MCAuto<DataArrayInt> safePfl(pflOut);
2583 MCAuto<DataArray> da=getOrCreateAndGetArray()->selectByTupleRanges(dads);
2584 const std::vector<std::string>& infos=getInfo();
2585 int nbOfComp=infos.size();
2586 for(int i=0;i<nbOfComp;i++)
2587 da->setInfoOnComponent(i,infos[i].c_str());
2598 static MFFPMIter *NewCell(const std::vector< std::pair<TypeOfField,INTERP_KERNEL::NormalizedCellType> > *entities);
2599 static bool IsPresenceOfNode(const std::vector< std::pair<TypeOfField,INTERP_KERNEL::NormalizedCellType> > *entities);
2600 virtual ~MFFPMIter() { }
2601 virtual void begin() = 0;
2602 virtual bool finished() const = 0;
2603 virtual void next() = 0;
2604 virtual int current() const = 0;
2607 class MFFPMIterSimple : public MFFPMIter
2610 MFFPMIterSimple():_pos(0) { }
2611 void begin() { _pos=0; }
2612 bool finished() const { return _pos>=MED_N_CELL_FIXED_GEO; }
2613 void next() { _pos++; }
2614 int current() const { return _pos; }
2619 class MFFPMIter2 : public MFFPMIter
2622 MFFPMIter2(const std::vector<INTERP_KERNEL::NormalizedCellType>& cts);
2623 void begin() { _it=_ids.begin(); }
2624 bool finished() const { return _it==_ids.end(); }
2625 void next() { _it++; }
2626 int current() const { return *_it; }
2628 std::vector<int> _ids;
2629 std::vector<int>::const_iterator _it;
2632 MFFPMIter *MFFPMIter::NewCell(const std::vector< std::pair<TypeOfField,INTERP_KERNEL::NormalizedCellType> > *entities)
2635 return new MFFPMIterSimple;
2638 std::vector<INTERP_KERNEL::NormalizedCellType> tmp;
2639 for(std::vector< std::pair<TypeOfField,INTERP_KERNEL::NormalizedCellType> >::const_iterator it=(*entities).begin();it!=(*entities).end();it++)
2641 if((*it).first==ON_CELLS || (*it).first==ON_GAUSS_NE || (*it).first==ON_GAUSS_PT)
2642 tmp.push_back((*it).second);
2644 return new MFFPMIter2(tmp);
2648 bool MFFPMIter::IsPresenceOfNode(const std::vector< std::pair<TypeOfField,INTERP_KERNEL::NormalizedCellType> > *entities)
2654 for(std::vector< std::pair<TypeOfField,INTERP_KERNEL::NormalizedCellType> >::const_iterator it=(*entities).begin();it!=(*entities).end();it++)
2655 if((*it).first==ON_NODES)
2661 MFFPMIter2::MFFPMIter2(const std::vector<INTERP_KERNEL::NormalizedCellType>& cts)
2663 std::size_t sz(cts.size());
2665 for(std::size_t i=0;i<sz;i++)
2667 INTERP_KERNEL::NormalizedCellType *loc(std::find(typmai2,typmai2+MED_N_CELL_FIXED_GEO,cts[i]));
2668 if(loc!=typmai2+MED_N_CELL_FIXED_GEO)
2669 _ids[i]=(int)std::distance(typmai2,loc);
2671 throw INTERP_KERNEL::Exception("MFFPMIter2 : The specified geo type does not exists !");
2677 MEDFileFieldPerMesh::MEDFileFieldPerMesh(med_idt fid, MEDFileAnyTypeField1TSWithoutSDA *fath, int meshCsit, int meshIteration, int meshOrder, const MEDFileFieldNameScope& nasc, const MEDFileMesh *mm, const std::vector< std::pair<TypeOfField,INTERP_KERNEL::NormalizedCellType> > *entities):_mesh_iteration(meshIteration),_mesh_order(meshOrder),
2680 INTERP_KERNEL::AutoPtr<char> meshName(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE));
2681 INTERP_KERNEL::AutoPtr<char> pflName(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE));
2682 INTERP_KERNEL::AutoPtr<char> locName(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE));
2683 const MEDFileUMesh *mmu(dynamic_cast<const MEDFileUMesh *>(mm));
2684 INTERP_KERNEL::AutoCppPtr<MFFPMIter> iter0(MFFPMIter::NewCell(entities));
2685 for(iter0->begin();!iter0->finished();iter0->next())
2687 int nbProfile (MEDfield23nProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_CELL ,typmai[iter0->current()],meshCsit+1,meshName,pflName,locName));
2688 std::string name0(MEDLoaderBase::buildStringFromFortran(meshName,MED_NAME_SIZE+1));
2689 int nbProfile2(MEDfield23nProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_NODE_ELEMENT,typmai[iter0->current()],meshCsit+1,meshName,pflName,locName));
2690 std::string name1(MEDLoaderBase::buildStringFromFortran(meshName,MED_NAME_SIZE+1));
2691 if(nbProfile>0 || nbProfile2>0)
2693 const PartDefinition *pd(0);
2695 pd=mmu->getPartDefAtLevel(mmu->getRelativeLevOnGeoType(typmai2[iter0->current()]),typmai2[iter0->current()]);
2696 _field_pm_pt.push_back(MEDFileFieldPerMeshPerType::NewOnRead(fid,this,ON_CELLS,typmai2[iter0->current()],nasc,pd));
2703 if(MFFPMIter::IsPresenceOfNode(entities))
2705 int nbProfile(MEDfield23nProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_NODE,MED_NONE,meshCsit+1,meshName,pflName,locName));
2708 const PartDefinition *pd(0);
2710 pd=mmu->getPartDefAtLevel(1,INTERP_KERNEL::NORM_ERROR);
2711 _field_pm_pt.push_back(MEDFileFieldPerMeshPerType::NewOnRead(fid,this,ON_NODES,INTERP_KERNEL::NORM_ERROR,nasc,pd));
2712 _mesh_name=MEDLoaderBase::buildStringFromFortran(meshName,MED_NAME_SIZE+1);
2717 MEDFileFieldPerMesh::MEDFileFieldPerMesh(MEDFileAnyTypeField1TSWithoutSDA *fath, const MEDCouplingMesh *mesh):_father(fath)
2719 copyTinyInfoFrom(mesh);
2722 void MEDFileFieldGlobs::loadProfileInFile(med_idt fid, int id, const std::string& pflName)
2724 if(id>=(int)_pfls.size())
2726 _pfls[id]=DataArrayInt::New();
2727 int lgth(MEDprofileSizeByName(fid,pflName.c_str()));
2728 _pfls[id]->setName(pflName);
2729 _pfls[id]->alloc(lgth,1);
2730 MEDFILESAFECALLERRD0(MEDprofileRd,(fid,pflName.c_str(),_pfls[id]->getPointer()));
2731 _pfls[id]->applyLin(1,-1,0);//Converting into C format
2734 void MEDFileFieldGlobs::loadProfileInFile(med_idt fid, int i)
2736 INTERP_KERNEL::AutoPtr<char> pflName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
2738 MEDFILESAFECALLERRD0(MEDprofileInfo,(fid,i+1,pflName,&sz));
2739 std::string pflCpp=MEDLoaderBase::buildStringFromFortran(pflName,MED_NAME_SIZE);
2740 if(i>=(int)_pfls.size())
2742 _pfls[i]=DataArrayInt::New();
2743 _pfls[i]->alloc(sz,1);
2744 _pfls[i]->setName(pflCpp.c_str());
2745 MEDFILESAFECALLERRD0(MEDprofileRd,(fid,pflName,_pfls[i]->getPointer()));
2746 _pfls[i]->applyLin(1,-1,0);//Converting into C format
2749 void MEDFileFieldGlobs::writeGlobals(med_idt fid, const MEDFileWritable& opt) const
2751 int nbOfPfls=_pfls.size();
2752 for(int i=0;i<nbOfPfls;i++)
2754 MCAuto<DataArrayInt> cpy=_pfls[i]->deepCopy();
2755 cpy->applyLin(1,1,0);
2756 INTERP_KERNEL::AutoPtr<char> pflName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
2757 MEDLoaderBase::safeStrCpy(_pfls[i]->getName().c_str(),MED_NAME_SIZE,pflName,opt.getTooLongStrPolicy());
2758 MEDFILESAFECALLERWR0(MEDprofileWr,(fid,pflName,_pfls[i]->getNumberOfTuples(),cpy->getConstPointer()));
2761 int nbOfLocs=_locs.size();
2762 for(int i=0;i<nbOfLocs;i++)
2763 _locs[i]->writeLL(fid);
2766 void MEDFileFieldGlobs::appendGlobs(const MEDFileFieldGlobs& other, double eps)
2768 std::vector<std::string> pfls=getPfls();
2769 for(std::vector< MCAuto<DataArrayInt> >::const_iterator it=other._pfls.begin();it!=other._pfls.end();it++)
2771 std::vector<std::string>::iterator it2=std::find(pfls.begin(),pfls.end(),(*it)->getName());
2774 _pfls.push_back(*it);
2778 int id=std::distance(pfls.begin(),it2);
2779 if(!(*it)->isEqual(*_pfls[id]))
2781 std::ostringstream oss; oss << "MEDFileFieldGlobs::appendGlobs : Profile \"" << (*it)->getName() << "\" already exists and is different from those expecting to be append !";
2782 throw INTERP_KERNEL::Exception(oss.str());
2786 std::vector<std::string> locs=getLocs();
2787 for(std::vector< MCAuto<MEDFileFieldLoc> >::const_iterator it=other._locs.begin();it!=other._locs.end();it++)
2789 std::vector<std::string>::iterator it2=std::find(locs.begin(),locs.end(),(*it)->getName());
2792 _locs.push_back(*it);
2796 int id=std::distance(locs.begin(),it2);
2797 if(!(*it)->isEqual(*_locs[id],eps))
2799 std::ostringstream oss; oss << "MEDFileFieldGlobs::appendGlobs : Localization \"" << (*it)->getName() << "\" already exists and is different from those expecting to be append !";
2800 throw INTERP_KERNEL::Exception(oss.str());
2806 void MEDFileFieldGlobs::checkGlobsPflsPartCoherency(const std::vector<std::string>& pflsUsed) const
2808 for(std::vector<std::string>::const_iterator it=pflsUsed.begin();it!=pflsUsed.end();it++)
2809 getProfile((*it).c_str());
2812 void MEDFileFieldGlobs::checkGlobsLocsPartCoherency(const std::vector<std::string>& locsUsed) const
2814 for(std::vector<std::string>::const_iterator it=locsUsed.begin();it!=locsUsed.end();it++)
2815 getLocalization((*it).c_str());
2818 void MEDFileFieldGlobs::loadGlobals(med_idt fid, const MEDFileFieldGlobsReal& real)
2820 std::vector<std::string> profiles=real.getPflsReallyUsed();
2821 int sz=profiles.size();
2823 for(int i=0;i<sz;i++)
2824 loadProfileInFile(fid,i,profiles[i].c_str());
2826 std::vector<std::string> locs=real.getLocsReallyUsed();
2829 for(int i=0;i<sz;i++)
2830 _locs[i]=MEDFileFieldLoc::New(fid,locs[i].c_str());
2833 void MEDFileFieldGlobs::loadAllGlobals(med_idt fid)
2835 int nProfil=MEDnProfile(fid);
2836 for(int i=0;i<nProfil;i++)
2837 loadProfileInFile(fid,i);
2838 int sz=MEDnLocalization(fid);
2840 for(int i=0;i<sz;i++)
2842 _locs[i]=MEDFileFieldLoc::New(fid,i);
2846 MEDFileFieldGlobs *MEDFileFieldGlobs::New(med_idt fid)
2848 return new MEDFileFieldGlobs(fid);
2851 MEDFileFieldGlobs *MEDFileFieldGlobs::New()
2853 return new MEDFileFieldGlobs;
2856 std::size_t MEDFileFieldGlobs::getHeapMemorySizeWithoutChildren() const
2858 return _file_name.capacity()+_pfls.capacity()*sizeof(MCAuto<DataArrayInt>)+_locs.capacity()*sizeof(MCAuto<MEDFileFieldLoc>);
2861 std::vector<const BigMemoryObject *> MEDFileFieldGlobs::getDirectChildrenWithNull() const
2863 std::vector<const BigMemoryObject *> ret;
2864 for(std::vector< MCAuto< DataArrayInt > >::const_iterator it=_pfls.begin();it!=_pfls.end();it++)
2865 ret.push_back((const DataArrayInt *)*it);
2866 for(std::vector< MCAuto<MEDFileFieldLoc> >::const_iterator it=_locs.begin();it!=_locs.end();it++)
2867 ret.push_back((const MEDFileFieldLoc *)*it);
2871 MEDFileFieldGlobs *MEDFileFieldGlobs::deepCopy() const
2873 MCAuto<MEDFileFieldGlobs> ret=new MEDFileFieldGlobs(*this);
2875 for(std::vector< MCAuto<DataArrayInt> >::const_iterator it=_pfls.begin();it!=_pfls.end();it++,i++)
2877 if((const DataArrayInt *)*it)
2878 ret->_pfls[i]=(*it)->deepCopy();
2881 for(std::vector< MCAuto<MEDFileFieldLoc> >::const_iterator it=_locs.begin();it!=_locs.end();it++,i++)
2883 if((const MEDFileFieldLoc*)*it)
2884 ret->_locs[i]=(*it)->deepCopy();
2890 * \throw if a profile in \a pfls in not in \a this.
2891 * \throw if a localization in \a locs in not in \a this.
2892 * \sa MEDFileFieldGlobs::deepCpyPart
2894 MEDFileFieldGlobs *MEDFileFieldGlobs::shallowCpyPart(const std::vector<std::string>& pfls, const std::vector<std::string>& locs) const
2896 MCAuto<MEDFileFieldGlobs> ret=MEDFileFieldGlobs::New();
2897 for(std::vector<std::string>::const_iterator it1=pfls.begin();it1!=pfls.end();it1++)
2899 DataArrayInt *pfl=const_cast<DataArrayInt *>(getProfile((*it1).c_str()));
2901 throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::shallowCpyPart : internal error ! pfl null !");
2903 MCAuto<DataArrayInt> pfl2(pfl);
2904 ret->_pfls.push_back(pfl2);
2906 for(std::vector<std::string>::const_iterator it2=locs.begin();it2!=locs.end();it2++)
2908 MEDFileFieldLoc *loc=const_cast<MEDFileFieldLoc *>(&getLocalization((*it2).c_str()));
2910 throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::shallowCpyPart : internal error ! loc null !");
2912 MCAuto<MEDFileFieldLoc> loc2(loc);
2913 ret->_locs.push_back(loc2);
2915 ret->setFileName(getFileName());
2920 * \throw if a profile in \a pfls in not in \a this.
2921 * \throw if a localization in \a locs in not in \a this.
2922 * \sa MEDFileFieldGlobs::shallowCpyPart
2924 MEDFileFieldGlobs *MEDFileFieldGlobs::deepCpyPart(const std::vector<std::string>& pfls, const std::vector<std::string>& locs) const
2926 MCAuto<MEDFileFieldGlobs> ret=MEDFileFieldGlobs::New();
2927 for(std::vector<std::string>::const_iterator it1=pfls.begin();it1!=pfls.end();it1++)
2929 DataArrayInt *pfl=const_cast<DataArrayInt *>(getProfile((*it1).c_str()));
2931 throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::deepCpyPart : internal error ! pfl null !");
2932 ret->_pfls.push_back(pfl->deepCopy());
2934 for(std::vector<std::string>::const_iterator it2=locs.begin();it2!=locs.end();it2++)
2936 MEDFileFieldLoc *loc=const_cast<MEDFileFieldLoc *>(&getLocalization((*it2).c_str()));
2938 throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::deepCpyPart : internal error ! loc null !");
2939 ret->_locs.push_back(loc->deepCopy());
2941 ret->setFileName(getFileName());
2945 MEDFileFieldGlobs::MEDFileFieldGlobs(med_idt fid):_file_name(MEDFileWritable::FileNameFromFID(fid))
2949 MEDFileFieldGlobs::MEDFileFieldGlobs()
2953 MEDFileFieldGlobs::~MEDFileFieldGlobs()
2957 void MEDFileFieldGlobs::simpleRepr(std::ostream& oss) const
2959 oss << "Profiles :\n";
2960 std::size_t n=_pfls.size();
2961 for(std::size_t i=0;i<n;i++)
2963 oss << " - #" << i << " ";
2964 const DataArrayInt *pfl=_pfls[i];
2966 oss << "\"" << pfl->getName() << "\"\n";
2971 oss << "Localizations :\n";
2972 for(std::size_t i=0;i<n;i++)
2974 oss << " - #" << i << " ";
2975 const MEDFileFieldLoc *loc=_locs[i];
2977 loc->simpleRepr(oss);
2983 void MEDFileFieldGlobs::changePflsNamesInStruct(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
2985 for(std::vector< MCAuto<DataArrayInt> >::iterator it=_pfls.begin();it!=_pfls.end();it++)
2987 DataArrayInt *elt(*it);
2990 std::string name(elt->getName());
2991 for(std::vector< std::pair<std::vector<std::string>, std::string > >::const_iterator it2=mapOfModif.begin();it2!=mapOfModif.end();it2++)
2993 if(std::find((*it2).first.begin(),(*it2).first.end(),name)!=(*it2).first.end())
2995 elt->setName((*it2).second.c_str());
3003 void MEDFileFieldGlobs::changeLocsNamesInStruct(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
3005 for(std::vector< MCAuto<MEDFileFieldLoc> >::iterator it=_locs.begin();it!=_locs.end();it++)
3007 MEDFileFieldLoc *elt(*it);
3010 std::string name(elt->getName());
3011 for(std::vector< std::pair<std::vector<std::string>, std::string > >::const_iterator it2=mapOfModif.begin();it2!=mapOfModif.end();it2++)
3013 if(std::find((*it2).first.begin(),(*it2).first.end(),name)!=(*it2).first.end())
3015 elt->setName((*it2).second.c_str());
3023 int MEDFileFieldGlobs::getNbOfGaussPtPerCell(int locId) const
3025 if(locId<0 || locId>=(int)_locs.size())
3026 throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::getNbOfGaussPtPerCell : Invalid localization id !");
3027 return _locs[locId]->getNbOfGaussPtPerCell();
3030 const MEDFileFieldLoc& MEDFileFieldGlobs::getLocalization(const std::string& locName) const
3032 return getLocalizationFromId(getLocalizationId(locName));
3035 const MEDFileFieldLoc& MEDFileFieldGlobs::getLocalizationFromId(int locId) const
3037 if(locId<0 || locId>=(int)_locs.size())
3038 throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::getLocalizationFromId : Invalid localization id !");
3039 return *_locs[locId];
3043 namespace MEDCouplingImpl
3048 LocFinder(const std::string& loc):_loc(loc) { }
3049 bool operator() (const MCAuto<MEDFileFieldLoc>& loc) { return loc->isName(_loc); }
3051 const std::string &_loc;
3057 PflFinder(const std::string& pfl):_pfl(pfl) { }
3058 bool operator() (const MCAuto<DataArrayInt>& pfl) { return _pfl==pfl->getName(); }
3060 const std::string& _pfl;
3065 int MEDFileFieldGlobs::getLocalizationId(const std::string& loc) const
3067 std::vector< MCAuto<MEDFileFieldLoc> >::const_iterator it=std::find_if(_locs.begin(),_locs.end(),MEDCouplingImpl::LocFinder(loc));
3070 std::ostringstream oss; oss << "MEDFileFieldGlobs::getLocalisationId : no such localisation name : \"" << loc << "\" Possible localizations are : ";
3071 for(it=_locs.begin();it!=_locs.end();it++)
3072 oss << "\"" << (*it)->getName() << "\", ";
3073 throw INTERP_KERNEL::Exception(oss.str());
3075 return std::distance(_locs.begin(),it);
3079 * The returned value is never null.
3081 const DataArrayInt *MEDFileFieldGlobs::getProfile(const std::string& pflName) const
3083 std::string pflNameCpp(pflName);
3084 std::vector< MCAuto<DataArrayInt> >::const_iterator it=std::find_if(_pfls.begin(),_pfls.end(),MEDCouplingImpl::PflFinder(pflNameCpp));
3087 std::ostringstream oss; oss << "MEDFileFieldGlobs::getProfile: no such profile name : \"" << pflNameCpp << "\" Possible profiles are : ";
3088 for(it=_pfls.begin();it!=_pfls.end();it++)
3089 oss << "\"" << (*it)->getName() << "\", ";
3090 throw INTERP_KERNEL::Exception(oss.str());
3095 const DataArrayInt *MEDFileFieldGlobs::getProfileFromId(int pflId) const
3097 if(pflId<0 || pflId>=(int)_pfls.size())
3098 throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::getProfileFromId : Invalid profile id !");
3099 return _pfls[pflId];
3102 MEDFileFieldLoc& MEDFileFieldGlobs::getLocalizationFromId(int locId)
3104 if(locId<0 || locId>=(int)_locs.size())
3105 throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::getLocalizationFromId : Invalid localization id !");
3106 return *_locs[locId];
3109 MEDFileFieldLoc& MEDFileFieldGlobs::getLocalization(const std::string& locName)
3111 return getLocalizationFromId(getLocalizationId(locName));
3115 * The returned value is never null.
3117 DataArrayInt *MEDFileFieldGlobs::getProfile(const std::string& pflName)
3119 std::string pflNameCpp(pflName);
3120 std::vector< MCAuto<DataArrayInt> >::iterator it=std::find_if(_pfls.begin(),_pfls.end(),MEDCouplingImpl::PflFinder(pflNameCpp));
3123 std::ostringstream oss; oss << "MEDFileFieldGlobs::getProfile: no such profile name : \"" << pflNameCpp << "\" Possible profiles are : ";
3124 for(it=_pfls.begin();it!=_pfls.end();it++)
3125 oss << "\"" << (*it)->getName() << "\", ";
3126 throw INTERP_KERNEL::Exception(oss.str());
3131 DataArrayInt *MEDFileFieldGlobs::getProfileFromId(int pflId)
3133 if(pflId<0 || pflId>=(int)_pfls.size())
3134 throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::getProfileFromId : Invalid profile id !");
3135 return _pfls[pflId];
3138 void MEDFileFieldGlobs::killProfileIds(const std::vector<int>& pflIds)
3140 std::vector< MCAuto<DataArrayInt> > newPfls;
3142 for(std::vector< MCAuto<DataArrayInt> >::const_iterator it=_pfls.begin();it!=_pfls.end();it++,i++)
3144 if(std::find(pflIds.begin(),pflIds.end(),i)==pflIds.end())
3145 newPfls.push_back(*it);
3150 void MEDFileFieldGlobs::killLocalizationIds(const std::vector<int>& locIds)
3152 std::vector< MCAuto<MEDFileFieldLoc> > newLocs;
3154 for(std::vector< MCAuto<MEDFileFieldLoc> >::const_iterator it=_locs.begin();it!=_locs.end();it++,i++)
3156 if(std::find(locIds.begin(),locIds.end(),i)==locIds.end())
3157 newLocs.push_back(*it);
3162 std::vector<std::string> MEDFileFieldGlobs::getPfls() const
3164 int sz=_pfls.size();
3165 std::vector<std::string> ret(sz);
3166 for(int i=0;i<sz;i++)
3167 ret[i]=_pfls[i]->getName();
3171 std::vector<std::string> MEDFileFieldGlobs::getLocs() const
3173 int sz=_locs.size();
3174 std::vector<std::string> ret(sz);
3175 for(int i=0;i<sz;i++)
3176 ret[i]=_locs[i]->getName();
3180 bool MEDFileFieldGlobs::existsPfl(const std::string& pflName) const
3182 std::vector<std::string> v=getPfls();
3183 std::string s(pflName);
3184 return std::find(v.begin(),v.end(),s)!=v.end();
3187 bool MEDFileFieldGlobs::existsLoc(const std::string& locName) const
3189 std::vector<std::string> v=getLocs();
3190 std::string s(locName);
3191 return std::find(v.begin(),v.end(),s)!=v.end();
3194 std::vector< std::vector<int> > MEDFileFieldGlobs::whichAreEqualProfiles() const
3196 std::map<int,std::vector<int> > m;
3198 for(std::vector< MCAuto<DataArrayInt> >::const_iterator it=_pfls.begin();it!=_pfls.end();it++,i++)
3200 const DataArrayInt *tmp=(*it);
3203 m[tmp->getHashCode()].push_back(i);
3206 std::vector< std::vector<int> > ret;
3207 for(std::map<int,std::vector<int> >::const_iterator it2=m.begin();it2!=m.end();it2++)
3209 if((*it2).second.size()>1)
3211 std::vector<int> ret0;
3212 bool equalityOrNot=false;
3213 for(std::vector<int>::const_iterator it3=(*it2).second.begin();it3!=(*it2).second.end();it3++)
3215 std::vector<int>::const_iterator it4=it3; it4++;
3216 for(;it4!=(*it2).second.end();it4++)
3218 if(_pfls[*it3]->isEqualWithoutConsideringStr(*_pfls[*it4]))
3221 ret0.push_back(*it3);
3222 ret0.push_back(*it4);
3228 ret.push_back(ret0);
3234 std::vector< std::vector<int> > MEDFileFieldGlobs::whichAreEqualLocs(double eps) const
3236 throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::whichAreEqualLocs : no implemented yet ! Sorry !");
3239 void MEDFileFieldGlobs::appendProfile(DataArrayInt *pfl)
3241 std::string name(pfl->getName());
3243 throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::appendProfile : unsupported profiles with no name !");
3244 for(std::vector< MCAuto<DataArrayInt> >::const_iterator it=_pfls.begin();it!=_pfls.end();it++)
3245 if(name==(*it)->getName())
3247 if(!pfl->isEqual(*(*it)))
3249 std::ostringstream oss; oss << "MEDFileFieldGlobs::appendProfile : profile \"" << name << "\" already exists and is different from existing !";
3250 throw INTERP_KERNEL::Exception(oss.str());
3254 _pfls.push_back(pfl);
3257 void MEDFileFieldGlobs::appendLoc(const std::string& locName, INTERP_KERNEL::NormalizedCellType geoType, const std::vector<double>& refCoo, const std::vector<double>& gsCoo, const std::vector<double>& w)
3259 std::string name(locName);
3261 throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::appendLoc : unsupported localizations with no name !");
3262 MCAuto<MEDFileFieldLoc> obj=MEDFileFieldLoc::New(locName,geoType,refCoo,gsCoo,w);
3263 for(std::vector< MCAuto<MEDFileFieldLoc> >::const_iterator it=_locs.begin();it!=_locs.end();it++)
3264 if((*it)->isName(locName))
3266 if(!(*it)->isEqual(*obj,1e-12))
3268 std::ostringstream oss; oss << "MEDFileFieldGlobs::appendLoc : localization \"" << name << "\" already exists and is different from existing !";
3269 throw INTERP_KERNEL::Exception(oss.str());
3272 _locs.push_back(obj);
3275 std::string MEDFileFieldGlobs::createNewNameOfPfl() const
3277 std::vector<std::string> names=getPfls();
3278 return CreateNewNameNotIn("NewPfl_",names);
3281 std::string MEDFileFieldGlobs::createNewNameOfLoc() const
3283 std::vector<std::string> names=getLocs();
3284 return CreateNewNameNotIn("NewLoc_",names);
3287 std::string MEDFileFieldGlobs::CreateNewNameNotIn(const std::string& prefix, const std::vector<std::string>& namesToAvoid)
3289 for(std::size_t sz=0;sz<100000;sz++)
3291 std::ostringstream tryName;
3292 tryName << prefix << sz;
3293 if(std::find(namesToAvoid.begin(),namesToAvoid.end(),tryName.str())==namesToAvoid.end())
3294 return tryName.str();
3296 throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::CreateNewNameNotIn : impossible to create an additional profile limit of 100000 profiles reached !");
3300 * Creates a MEDFileFieldGlobsReal on a given file name. Nothing is read here.
3301 * \param [in] fname - the file name.
3303 MEDFileFieldGlobsReal::MEDFileFieldGlobsReal(med_idt fid):_globals(MEDFileFieldGlobs::New(fid))
3308 * Creates an empty MEDFileFieldGlobsReal.
3310 MEDFileFieldGlobsReal::MEDFileFieldGlobsReal():_globals(MEDFileFieldGlobs::New())
3314 std::size_t MEDFileFieldGlobsReal::getHeapMemorySizeWithoutChildren() const
3319 std::vector<const BigMemoryObject *> MEDFileFieldGlobsReal::getDirectChildrenWithNull() const
3321 std::vector<const BigMemoryObject *> ret;
3322 ret.push_back((const MEDFileFieldGlobs *)_globals);
3327 * Returns a string describing profiles and Gauss points held in \a this.
3328 * \return std::string - the description string.
3330 void MEDFileFieldGlobsReal::simpleReprGlobs(std::ostream& oss) const
3332 const MEDFileFieldGlobs *glob=_globals;
3333 std::ostringstream oss2; oss2 << glob;
3334 std::string stars(oss2.str().length(),'*');
3335 oss << "Globals information on fields (at " << oss2.str() << "):" << "\n************************************" << stars << "\n\n";
3337 glob->simpleRepr(oss);
3339 oss << "NO GLOBAL INFORMATION !\n";
3342 void MEDFileFieldGlobsReal::resetContent()
3344 _globals=MEDFileFieldGlobs::New();
3347 MEDFileFieldGlobsReal::~MEDFileFieldGlobsReal()
3352 * Copies references to profiles and Gauss points from another MEDFileFieldGlobsReal.
3353 * \param [in] other - the other MEDFileFieldGlobsReal to copy data from.
3355 void MEDFileFieldGlobsReal::shallowCpyGlobs(const MEDFileFieldGlobsReal& other)
3357 _globals=other._globals;
3361 * Copies references to ** only used ** by \a this, profiles and Gauss points from another MEDFileFieldGlobsReal.
3362 * \param [in] other - the other MEDFileFieldGlobsReal to copy data from.
3364 void MEDFileFieldGlobsReal::shallowCpyOnlyUsedGlobs(const MEDFileFieldGlobsReal& other)
3366 const MEDFileFieldGlobs *otherg(other._globals);
3369 _globals=otherg->shallowCpyPart(getPflsReallyUsed(),getLocsReallyUsed());
3373 * Copies deeply to ** only used ** by \a this, profiles and Gauss points from another MEDFileFieldGlobsReal.
3374 * \param [in] other - the other MEDFileFieldGlobsReal to copy data from.
3376 void MEDFileFieldGlobsReal::deepCpyOnlyUsedGlobs(const MEDFileFieldGlobsReal& other)
3378 const MEDFileFieldGlobs *otherg(other._globals);
3381 _globals=otherg->deepCpyPart(getPflsReallyUsed(),getLocsReallyUsed());
3384 void MEDFileFieldGlobsReal::deepCpyGlobs(const MEDFileFieldGlobsReal& other)
3386 _globals=other._globals;
3387 if((const MEDFileFieldGlobs *)_globals)
3388 _globals=other._globals->deepCopy();
3392 * Adds profiles and Gauss points held by another MEDFileFieldGlobsReal to \a this one.
3393 * \param [in] other - the MEDFileFieldGlobsReal to copy data from.
3394 * \param [in] eps - a precision used to compare Gauss points with same name held by
3395 * \a this and \a other MEDFileFieldGlobsReal.
3396 * \throw If \a this and \a other hold profiles with equal names but different ids.
3397 * \throw If \a this and \a other hold different Gauss points with equal names.
3399 void MEDFileFieldGlobsReal::appendGlobs(const MEDFileFieldGlobsReal& other, double eps)
3401 const MEDFileFieldGlobs *thisGlobals(_globals),*otherGlobals(other._globals);
3402 if(thisGlobals==otherGlobals)
3406 _globals=other._globals;
3409 _globals->appendGlobs(*other._globals,eps);
3412 void MEDFileFieldGlobsReal::checkGlobsCoherency() const
3414 checkGlobsPflsPartCoherency();
3415 checkGlobsLocsPartCoherency();
3418 void MEDFileFieldGlobsReal::checkGlobsPflsPartCoherency() const
3420 contentNotNull()->checkGlobsPflsPartCoherency(getPflsReallyUsed());
3423 void MEDFileFieldGlobsReal::checkGlobsLocsPartCoherency() const
3425 contentNotNull()->checkGlobsLocsPartCoherency(getLocsReallyUsed());
3428 void MEDFileFieldGlobsReal::loadProfileInFile(med_idt fid, int id, const std::string& pflName)
3430 contentNotNull()->loadProfileInFile(fid,id,pflName);
3433 void MEDFileFieldGlobsReal::loadProfileInFile(med_idt fid, int id)
3435 contentNotNull()->loadProfileInFile(fid,id);
3438 void MEDFileFieldGlobsReal::loadGlobals(med_idt fid)
3440 contentNotNull()->loadGlobals(fid,*this);
3443 void MEDFileFieldGlobsReal::loadAllGlobals(med_idt fid)
3445 contentNotNull()->loadAllGlobals(fid);
3448 void MEDFileFieldGlobsReal::writeGlobals(med_idt fid, const MEDFileWritable& opt) const
3450 contentNotNull()->writeGlobals(fid,opt);
3454 * Returns names of all profiles. To get only used profiles call getPflsReallyUsed()
3455 * or getPflsReallyUsedMulti().
3456 * \return std::vector<std::string> - a sequence of names of all profiles.
3458 std::vector<std::string> MEDFileFieldGlobsReal::getPfls() const
3460 return contentNotNull()->getPfls();
3464 * Returns names of all localizations. To get only used localizations call getLocsReallyUsed()
3465 * or getLocsReallyUsedMulti().
3466 * \return std::vector<std::string> - a sequence of names of all localizations.
3468 std::vector<std::string> MEDFileFieldGlobsReal::getLocs() const
3470 return contentNotNull()->getLocs();
3474 * Checks if the profile with a given name exists.
3475 * \param [in] pflName - the profile name of interest.
3476 * \return bool - \c true if the profile named \a pflName exists.
3478 bool MEDFileFieldGlobsReal::existsPfl(const std::string& pflName) const
3480 return contentNotNull()->existsPfl(pflName);
3484 * Checks if the localization with a given name exists.
3485 * \param [in] locName - the localization name of interest.
3486 * \return bool - \c true if the localization named \a locName exists.
3488 bool MEDFileFieldGlobsReal::existsLoc(const std::string& locName) const
3490 return contentNotNull()->existsLoc(locName);
3493 std::string MEDFileFieldGlobsReal::createNewNameOfPfl() const
3495 return contentNotNull()->createNewNameOfPfl();
3498 std::string MEDFileFieldGlobsReal::createNewNameOfLoc() const
3500 return contentNotNull()->createNewNameOfLoc();
3504 * Sets the name of a MED file.
3505 * \param [inout] fileName - the file name.
3507 void MEDFileFieldGlobsReal::setFileName(const std::string& fileName)
3509 contentNotNull()->setFileName(fileName);
3513 * Finds equal profiles. Two profiles are considered equal if they contain the same ids
3514 * in the same order.
3515 * \return std::vector< std::vector<int> > - a sequence of groups of equal profiles.
3516 * Each item of this sequence is a vector containing ids of equal profiles.
3518 std::vector< std::vector<int> > MEDFileFieldGlobsReal::whichAreEqualProfiles() const
3520 return contentNotNull()->whichAreEqualProfiles();
3524 * Finds equal localizations.
3525 * \param [in] eps - a precision used to compare real values of the localizations.
3526 * \return std::vector< std::vector<int> > - a sequence of groups of equal localizations.
3527 * Each item of this sequence is a vector containing ids of equal localizations.
3529 std::vector< std::vector<int> > MEDFileFieldGlobsReal::whichAreEqualLocs(double eps) const
3531 return contentNotNull()->whichAreEqualLocs(eps);
3535 * Renames the profiles. References to profiles (a reference is a profile name) are not changed.
3536 * \param [in] mapOfModif - a sequence describing required renaming. Each element of
3537 * this sequence is a pair whose
3538 * - the first item is a vector of profile names to replace by the second item,
3539 * - the second item is a profile name to replace every profile name of the first item.
3541 void MEDFileFieldGlobsReal::changePflsNamesInStruct(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
3543 contentNotNull()->changePflsNamesInStruct(mapOfModif);
3547 * Renames the localizations. References to localizations (a reference is a localization name) are not changed.
3548 * \param [in] mapOfModif - a sequence describing required renaming. Each element of
3549 * this sequence is a pair whose
3550 * - the first item is a vector of localization names to replace by the second item,
3551 * - the second item is a localization name to replace every localization name of the first item.
3553 void MEDFileFieldGlobsReal::changeLocsNamesInStruct(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
3555 contentNotNull()->changeLocsNamesInStruct(mapOfModif);
3559 * Replaces references to some profiles (a reference is a profile name) by references
3560 * to other profiles and, contrary to changePflsRefsNamesGen(), renames the profiles
3561 * them-selves accordingly. <br>
3562 * This method is a generalization of changePflName().
3563 * \param [in] mapOfModif - a sequence describing required replacements. Each element of
3564 * this sequence is a pair whose
3565 * - the first item is a vector of profile names to replace by the second item,
3566 * - the second item is a profile name to replace every profile of the first item.
3567 * \sa changePflsRefsNamesGen()
3568 * \sa changePflName()
3570 void MEDFileFieldGlobsReal::changePflsNames(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
3572 changePflsRefsNamesGen(mapOfModif);
3573 changePflsNamesInStruct(mapOfModif);
3577 * Replaces references to some localizations (a reference is a localization name) by references
3578 * to other localizations and, contrary to changeLocsRefsNamesGen(), renames the localizations
3579 * them-selves accordingly. <br>
3580 * This method is a generalization of changeLocName().
3581 * \param [in] mapOfModif - a sequence describing required replacements. Each element of
3582 * this sequence is a pair whose
3583 * - the first item is a vector of localization names to replace by the second item,
3584 * - the second item is a localization name to replace every localization of the first item.
3585 * \sa changeLocsRefsNamesGen()
3586 * \sa changeLocName()
3588 void MEDFileFieldGlobsReal::changeLocsNames(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
3590 changeLocsRefsNamesGen(mapOfModif);
3591 changeLocsNamesInStruct(mapOfModif);
3595 * Renames the profile having a given name and updates references to this profile.
3596 * \param [in] oldName - the name of the profile to rename.
3597 * \param [in] newName - a new name of the profile.
3598 * \sa changePflsNames().
3600 void MEDFileFieldGlobsReal::changePflName(const std::string& oldName, const std::string& newName)
3602 std::vector< std::pair<std::vector<std::string>, std::string > > mapOfModif(1);
3603 std::pair<std::vector<std::string>, std::string > p(std::vector<std::string>(1,std::string(oldName)),std::string(newName));
3605 changePflsNames(mapOfModif);
3609 * Renames the localization having a given name and updates references to this localization.
3610 * \param [in] oldName - the name of the localization to rename.
3611 * \param [in] newName - a new name of the localization.
3612 * \sa changeLocsNames().
3614 void MEDFileFieldGlobsReal::changeLocName(const std::string& oldName, const std::string& newName)
3616 std::vector< std::pair<std::vector<std::string>, std::string > > mapOfModif(1);
3617 std::pair<std::vector<std::string>, std::string > p(std::vector<std::string>(1,std::string(oldName)),std::string(newName));
3619 changeLocsNames(mapOfModif);
3623 * Removes duplicated profiles. Returns a map used to update references to removed
3624 * profiles via changePflsRefsNamesGen().
3625 * Equal profiles are found using whichAreEqualProfiles().
3626 * \return std::vector< std::pair<std::vector<std::string>, std::string > > -
3627 * a sequence describing the performed replacements of profiles. Each element of
3628 * this sequence is a pair whose
3629 * - the first item is a vector of profile names replaced by the second item,
3630 * - the second item is a profile name replacing every profile of the first item.
3632 std::vector< std::pair<std::vector<std::string>, std::string > > MEDFileFieldGlobsReal::zipPflsNames()
3634 std::vector< std::vector<int> > pseudoRet=whichAreEqualProfiles();
3635 std::vector< std::pair<std::vector<std::string>, std::string > > ret(pseudoRet.size());
3637 for(std::vector< std::vector<int> >::const_iterator it=pseudoRet.begin();it!=pseudoRet.end();it++,i++)
3639 std::vector< std::string > tmp((*it).size());
3641 for(std::vector<int>::const_iterator it2=(*it).begin();it2!=(*it).end();it2++,j++)
3642 tmp[j]=std::string(getProfileFromId(*it2)->getName());
3643 std::pair<std::vector<std::string>, std::string > p(tmp,tmp.front());
3645 std::vector<int> tmp2((*it).begin()+1,(*it).end());
3646 killProfileIds(tmp2);
3648 changePflsRefsNamesGen(ret);
3653 * Removes duplicated localizations. Returns a map used to update references to removed
3654 * localizations via changeLocsRefsNamesGen().
3655 * Equal localizations are found using whichAreEqualLocs().
3656 * \param [in] eps - a precision used to compare real values of the localizations.
3657 * \return std::vector< std::pair<std::vector<std::string>, std::string > > -
3658 * a sequence describing the performed replacements of localizations. Each element of
3659 * this sequence is a pair whose
3660 * - the first item is a vector of localization names replaced by the second item,
3661 * - the second item is a localization name replacing every localization of the first item.
3663 std::vector< std::pair<std::vector<std::string>, std::string > > MEDFileFieldGlobsReal::zipLocsNames(double eps)
3665 std::vector< std::vector<int> > pseudoRet=whichAreEqualLocs(eps);
3666 std::vector< std::pair<std::vector<std::string>, std::string > > ret(pseudoRet.size());
3668 for(std::vector< std::vector<int> >::const_iterator it=pseudoRet.begin();it!=pseudoRet.end();it++,i++)
3670 std::vector< std::string > tmp((*it).size());
3672 for(std::vector<int>::const_iterator it2=(*it).begin();it2!=(*it).end();it2++,j++)
3673 tmp[j]=std::string(getLocalizationFromId(*it2).getName());
3674 std::pair<std::vector<std::string>, std::string > p(tmp,tmp.front());
3676 std::vector<int> tmp2((*it).begin()+1,(*it).end());
3677 killLocalizationIds(tmp2);
3679 changeLocsRefsNamesGen(ret);
3684 * Returns number of Gauss points per cell in a given localization.
3685 * \param [in] locId - an id of the localization of interest.
3686 * \return int - the number of the Gauss points per cell.
3688 int MEDFileFieldGlobsReal::getNbOfGaussPtPerCell(int locId) const
3690 return contentNotNull()->getNbOfGaussPtPerCell(locId);
3694 * Returns an id of a localization by its name.
3695 * \param [in] loc - the localization name of interest.
3696 * \return int - the id of the localization.
3697 * \throw If there is no a localization named \a loc.
3699 int MEDFileFieldGlobsReal::getLocalizationId(const std::string& loc) const
3701 return contentNotNull()->getLocalizationId(loc);
3705 * Returns the name of the MED file.
3706 * \return const std::string& - the MED file name.
3708 std::string MEDFileFieldGlobsReal::getFileName() const
3710 return contentNotNull()->getFileName();
3714 * Returns a localization object by its name.
3715 * \param [in] locName - the name of the localization of interest.
3716 * \return const MEDFileFieldLoc& - the localization object having the name \a locName.
3717 * \throw If there is no a localization named \a locName.
3719 const MEDFileFieldLoc& MEDFileFieldGlobsReal::getLocalization(const std::string& locName) const
3721 return contentNotNull()->getLocalization(locName);
3725 * Returns a localization object by its id.
3726 * \param [in] locId - the id of the localization of interest.
3727 * \return const MEDFileFieldLoc& - the localization object having the id \a locId.
3728 * \throw If there is no a localization with id \a locId.
3730 const MEDFileFieldLoc& MEDFileFieldGlobsReal::getLocalizationFromId(int locId) const
3732 return contentNotNull()->getLocalizationFromId(locId);
3736 * Returns a profile array by its name.
3737 * \param [in] pflName - the name of the profile of interest.
3738 * \return const DataArrayInt * - the profile array having the name \a pflName.
3739 * \throw If there is no a profile named \a pflName.
3741 const DataArrayInt *MEDFileFieldGlobsReal::getProfile(const std::string& pflName) const
3743 return contentNotNull()->getProfile(pflName);
3747 * Returns a profile array by its id.
3748 * \param [in] pflId - the id of the profile of interest.
3749 * \return const DataArrayInt * - the profile array having the id \a pflId.
3750 * \throw If there is no a profile with id \a pflId.
3752 const DataArrayInt *MEDFileFieldGlobsReal::getProfileFromId(int pflId) const
3754 return contentNotNull()->getProfileFromId(pflId);
3758 * Returns a localization object, apt for modification, by its id.
3759 * \param [in] locId - the id of the localization of interest.
3760 * \return MEDFileFieldLoc& - a non-const reference to the localization object
3761 * having the id \a locId.
3762 * \throw If there is no a localization with id \a locId.
3764 MEDFileFieldLoc& MEDFileFieldGlobsReal::getLocalizationFromId(int locId)
3766 return contentNotNull()->getLocalizationFromId(locId);
3770 * Returns a localization object, apt for modification, by its name.
3771 * \param [in] locName - the name of the localization of interest.
3772 * \return MEDFileFieldLoc& - a non-const reference to the localization object
3773 * having the name \a locName.
3774 * \throw If there is no a localization named \a locName.
3776 MEDFileFieldLoc& MEDFileFieldGlobsReal::getLocalization(const std::string& locName)
3778 return contentNotNull()->getLocalization(locName);
3782 * Returns a profile array, apt for modification, by its name.
3783 * \param [in] pflName - the name of the profile of interest.
3784 * \return DataArrayInt * - a non-const pointer to the profile array having the name \a pflName.
3785 * \throw If there is no a profile named \a pflName.
3787 DataArrayInt *MEDFileFieldGlobsReal::getProfile(const std::string& pflName)
3789 return contentNotNull()->getProfile(pflName);
3793 * Returns a profile array, apt for modification, by its id.
3794 * \param [in] pflId - the id of the profile of interest.
3795 * \return DataArrayInt * - a non-const pointer to the profile array having the id \a pflId.
3796 * \throw If there is no a profile with id \a pflId.
3798 DataArrayInt *MEDFileFieldGlobsReal::getProfileFromId(int pflId)
3800 return contentNotNull()->getProfileFromId(pflId);
3804 * Removes profiles given by their ids. No data is updated to track this removal.
3805 * \param [in] pflIds - a sequence of ids of the profiles to remove.
3807 void MEDFileFieldGlobsReal::killProfileIds(const std::vector<int>& pflIds)
3809 contentNotNull()->killProfileIds(pflIds);
3813 * Removes localizations given by their ids. No data is updated to track this removal.
3814 * \param [in] locIds - a sequence of ids of the localizations to remove.
3816 void MEDFileFieldGlobsReal::killLocalizationIds(const std::vector<int>& locIds)
3818 contentNotNull()->killLocalizationIds(locIds);
3822 * Stores a profile array.
3823 * \param [in] pfl - the profile array to store.
3824 * \throw If the name of \a pfl is empty.
3825 * \throw If a profile with the same name as that of \a pfl already exists but contains
3828 void MEDFileFieldGlobsReal::appendProfile(DataArrayInt *pfl)
3830 contentNotNull()->appendProfile(pfl);
3834 * Adds a new localization of Gauss points.
3835 * \param [in] locName - the name of the new localization.
3836 * \param [in] geoType - a geometrical type of the reference cell.
3837 * \param [in] refCoo - coordinates of points of the reference cell. Size of this vector
3838 * must be \c nbOfNodesPerCell * \c dimOfType.
3839 * \param [in] gsCoo - coordinates of Gauss points on the reference cell. Size of this vector
3840 * must be _wg_.size() * \c dimOfType.
3841 * \param [in] w - the weights of Gauss points.
3842 * \throw If \a locName is empty.
3843 * \throw If a localization with the name \a locName already exists but is
3844 * different form the new one.
3846 void MEDFileFieldGlobsReal::appendLoc(const std::string& locName, INTERP_KERNEL::NormalizedCellType geoType, const std::vector<double>& refCoo, const std::vector<double>& gsCoo, const std::vector<double>& w)
3848 contentNotNull()->appendLoc(locName,geoType,refCoo,gsCoo,w);
3851 MEDFileFieldGlobs *MEDFileFieldGlobsReal::contentNotNull()
3853 MEDFileFieldGlobs *g(_globals);
3855 throw INTERP_KERNEL::Exception("MEDFileFieldGlobsReal::contentNotNull : no content in not const !");
3859 const MEDFileFieldGlobs *MEDFileFieldGlobsReal::contentNotNull() const
3861 const MEDFileFieldGlobs *g(_globals);
3863 throw INTERP_KERNEL::Exception("MEDFileFieldGlobsReal::contentNotNull : no content in const !");
3867 //= MEDFileFieldNameScope
3869 MEDFileFieldNameScope::MEDFileFieldNameScope()
3873 MEDFileFieldNameScope::MEDFileFieldNameScope(const std::string& fieldName):_name(fieldName)
3878 * Returns the name of \a this field.
3879 * \return std::string - a string containing the field name.
3881 std::string MEDFileFieldNameScope::getName() const
3887 * Sets name of \a this field
3888 * \param [in] name - the new field name.
3890 void MEDFileFieldNameScope::setName(const std::string& fieldName)
3895 std::string MEDFileFieldNameScope::getDtUnit() const
3900 void MEDFileFieldNameScope::setDtUnit(const std::string& dtUnit)
3905 void MEDFileFieldNameScope::copyNameScope(const MEDFileFieldNameScope& other)
3908 _dt_unit=other._dt_unit;
3911 //= MEDFileAnyTypeField1TSWithoutSDA
3913 void MEDFileAnyTypeField1TSWithoutSDA::deepCpyLeavesFrom(const MEDFileAnyTypeField1TSWithoutSDA& other)
3915 _field_per_mesh.resize(other._field_per_mesh.size());
3917 for(std::vector< MCAuto< MEDFileFieldPerMesh > >::const_iterator it=other._field_per_mesh.begin();it!=other._field_per_mesh.end();it++,i++)
3919 if((const MEDFileFieldPerMesh *)*it)
3920 _field_per_mesh[i]=(*it)->deepCopy(this);
3925 * Prints a string describing \a this field into a stream. This string is outputted
3926 * by \c print Python command.
3927 * \param [in] bkOffset - number of white spaces printed at the beginning of each line.
3928 * \param [in,out] oss - the out stream.
3929 * \param [in] f1tsId - the field index within a MED file. If \a f1tsId < 0, the tiny
3930 * info id printed, else, not.
3932 void MEDFileAnyTypeField1TSWithoutSDA::simpleRepr(int bkOffset, std::ostream& oss, int f1tsId) const
3934 std::string startOfLine(bkOffset,' ');
3935 oss << startOfLine << "Field ";
3937 oss << "[Type=" << getTypeStr() << "] with name \"" << getName() << "\" ";
3938 oss << "on one time Step ";
3940 oss << "(" << f1tsId << ") ";
3941 oss << "on iteration=" << _iteration << " order=" << _order << "." << std::endl;
3942 oss << startOfLine << "Time attached is : " << _dt << " [" << _dt_unit << "]." << std::endl;
3943 const DataArray *arr=getUndergroundDataArray();
3946 const std::vector<std::string> &comps=arr->getInfoOnComponents();
3949 oss << startOfLine << "Field has " << comps.size() << " components with the following infos :" << std::endl;
3950 for(std::vector<std::string>::const_iterator it=comps.begin();it!=comps.end();it++)
3951 oss << startOfLine << " - \"" << (*it) << "\"" << std::endl;
3953 if(arr->isAllocated())
3955 oss << startOfLine << "Whole field contains " << arr->getNumberOfTuples() << " tuples." << std::endl;
3958 oss << startOfLine << "The array of the current field has not allocated yet !" << std::endl;
3962 oss << startOfLine << "Field infos are empty ! Not defined yet !" << std::endl;
3964 oss << startOfLine << "----------------------" << std::endl;
3965 if(!_field_per_mesh.empty())
3968 for(std::vector< MCAuto< MEDFileFieldPerMesh > >::const_iterator it2=_field_per_mesh.begin();it2!=_field_per_mesh.end();it2++,i++)
3970 const MEDFileFieldPerMesh *cur=(*it2);
3972 cur->simpleRepr(bkOffset,oss,i);
3974 oss << startOfLine << "Field per mesh #" << i << " is not defined !" << std::endl;
3979 oss << startOfLine << "Field is not defined on any meshes !" << std::endl;
3981 oss << startOfLine << "----------------------" << std::endl;
3984 std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > MEDFileAnyTypeField1TSWithoutSDA::splitComponents() const
3986 const DataArray *arr(getUndergroundDataArray());
3988 throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::splitComponents : no array defined !");
3989 int nbOfCompo=arr->getNumberOfComponents();
3990 std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > ret(nbOfCompo);
3991 for(int i=0;i<nbOfCompo;i++)
3994 std::vector<int> v(1,i);
3995 MCAuto<DataArray> arr2=arr->keepSelectedComponents(v);
3996 ret[i]->setArray(arr2);
4001 MEDFileAnyTypeField1TSWithoutSDA::MEDFileAnyTypeField1TSWithoutSDA(const std::string& fieldName, int csit, int iteration, int order):MEDFileFieldNameScope(fieldName),_iteration(iteration),_order(order),_csit(csit),_nb_of_tuples_to_be_allocated(-2)
4005 MEDFileAnyTypeField1TSWithoutSDA::MEDFileAnyTypeField1TSWithoutSDA():_iteration(-1),_order(-1),_dt(0.),_csit(-1),_nb_of_tuples_to_be_allocated(-1)
4010 * Returns the maximal dimension of supporting elements. Returns -2 if \a this is
4011 * empty. Returns -1 if this in on nodes.
4012 * \return int - the dimension of \a this.
4014 int MEDFileAnyTypeField1TSWithoutSDA::getDimension() const
4017 for(std::vector< MCAuto< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4018 (*it)->getDimension(ret);
4023 * Returns the mesh name.
4024 * \return std::string - a string holding the mesh name.
4025 * \throw If \c _field_per_mesh.empty()
4027 std::string MEDFileAnyTypeField1TSWithoutSDA::getMeshName() const
4029 if(_field_per_mesh.empty())
4030 throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::getMeshName : No field set !");
4031 return _field_per_mesh[0]->getMeshName();
4034 void MEDFileAnyTypeField1TSWithoutSDA::setMeshName(const std::string& newMeshName)
4036 std::string oldName(getMeshName());
4037 std::vector< std::pair<std::string,std::string> > v(1);
4038 v[0].first=oldName; v[0].second=newMeshName;
4042 bool MEDFileAnyTypeField1TSWithoutSDA::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab)
4045 for(std::vector< MCAuto< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4047 MEDFileFieldPerMesh *cur(*it);
4049 ret=cur->changeMeshNames(modifTab) || ret;
4055 * Returns the number of iteration of the state of underlying mesh.
4056 * \return int - the iteration number.
4057 * \throw If \c _field_per_mesh.empty()
4059 int MEDFileAnyTypeField1TSWithoutSDA::getMeshIteration() const
4061 if(_field_per_mesh.empty())
4062 throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::getMeshIteration : No field set !");
4063 return _field_per_mesh[0]->getMeshIteration();
4067 * Returns the order number of iteration of the state of underlying mesh.
4068 * \return int - the order number.
4069 * \throw If \c _field_per_mesh.empty()
4071 int MEDFileAnyTypeField1TSWithoutSDA::getMeshOrder() const
4073 if(_field_per_mesh.empty())
4074 throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::getMeshOrder : No field set !");
4075 return _field_per_mesh[0]->getMeshOrder();
4079 * Checks if \a this field is tagged by a given iteration number and a given
4080 * iteration order number.
4081 * \param [in] iteration - the iteration number of interest.
4082 * \param [in] order - the iteration order number of interest.
4083 * \return bool - \c true if \a this->getIteration() == \a iteration &&
4084 * \a this->getOrder() == \a order.
4086 bool MEDFileAnyTypeField1TSWithoutSDA::isDealingTS(int iteration, int order) const
4088 return iteration==_iteration && order==_order;
4092 * Returns number of iteration and order number of iteration when
4093 * \a this field has been calculated.
4094 * \return std::pair<int,int> - a pair of the iteration number and the iteration
4097 std::pair<int,int> MEDFileAnyTypeField1TSWithoutSDA::getDtIt() const
4099 std::pair<int,int> p;
4105 * Returns number of iteration and order number of iteration when
4106 * \a this field has been calculated.
4107 * \param [in,out] p - a pair returning the iteration number and the iteration
4110 void MEDFileAnyTypeField1TSWithoutSDA::fillIteration(std::pair<int,int>& p) const
4117 * Returns all types of spatial discretization of \a this field.
4118 * \param [in,out] types - a sequence of types of \a this field.
4120 void MEDFileAnyTypeField1TSWithoutSDA::fillTypesOfFieldAvailable(std::vector<TypeOfField>& types) const
4122 std::set<TypeOfField> types2;
4123 for(std::vector< MCAuto< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4125 (*it)->fillTypesOfFieldAvailable(types2);
4127 std::back_insert_iterator< std::vector<TypeOfField> > bi(types);
4128 std::copy(types2.begin(),types2.end(),bi);
4132 * Returns all types of spatial discretization of \a this field.
4133 * \return std::vector<TypeOfField> - a sequence of types of spatial discretization
4136 std::vector<TypeOfField> MEDFileAnyTypeField1TSWithoutSDA::getTypesOfFieldAvailable() const
4138 std::vector<TypeOfField> ret;
4139 fillTypesOfFieldAvailable(ret);
4143 std::vector<std::string> MEDFileAnyTypeField1TSWithoutSDA::getPflsReallyUsed2() const
4145 std::vector<std::string> ret;
4146 std::set<std::string> ret2;
4147 for(std::vector< MCAuto< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4149 std::vector<std::string> tmp=(*it)->getPflsReallyUsed();
4150 for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
4151 if(ret2.find(*it2)==ret2.end())
4153 ret.push_back(*it2);
4160 std::vector<std::string> MEDFileAnyTypeField1TSWithoutSDA::getLocsReallyUsed2() const
4162 std::vector<std::string> ret;
4163 std::set<std::string> ret2;
4164 for(std::vector< MCAuto< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4166 std::vector<std::string> tmp=(*it)->getLocsReallyUsed();
4167 for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
4168 if(ret2.find(*it2)==ret2.end())
4170 ret.push_back(*it2);
4177 std::vector<std::string> MEDFileAnyTypeField1TSWithoutSDA::getPflsReallyUsedMulti2() const
4179 std::vector<std::string> ret;
4180 for(std::vector< MCAuto< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4182 std::vector<std::string> tmp=(*it)->getPflsReallyUsedMulti();
4183 ret.insert(ret.end(),tmp.begin(),tmp.end());
4188 std::vector<std::string> MEDFileAnyTypeField1TSWithoutSDA::getLocsReallyUsedMulti2() const
4190 std::vector<std::string> ret;
4191 std::set<std::string> ret2;
4192 for(std::vector< MCAuto< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4194 std::vector<std::string> tmp=(*it)->getLocsReallyUsedMulti();
4195 ret.insert(ret.end(),tmp.begin(),tmp.end());
4200 void MEDFileAnyTypeField1TSWithoutSDA::changePflsRefsNamesGen2(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
4202 for(std::vector< MCAuto< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4203 (*it)->changePflsRefsNamesGen(mapOfModif);
4206 void MEDFileAnyTypeField1TSWithoutSDA::changeLocsRefsNamesGen2(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
4208 for(std::vector< MCAuto< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4209 (*it)->changeLocsRefsNamesGen(mapOfModif);
4213 * Returns all attributes of parts of \a this field lying on a given mesh.
4214 * Each part differs from other ones by a type of supporting mesh entity. The _i_-th
4215 * item of every of returned sequences refers to the _i_-th part of \a this field.
4216 * Thus all sequences returned by this method are of the same length equal to number
4217 * of different types of supporting entities.<br>
4218 * A field part can include sub-parts with several different spatial discretizations,
4219 * \ref MEDCoupling::ON_CELLS "ON_CELLS" and \ref MEDCoupling::ON_GAUSS_PT "ON_GAUSS_PT"
4220 * for example. Hence, some of the returned sequences contains nested sequences, and an item
4221 * of a nested sequence corresponds to a type of spatial discretization.<br>
4222 * This method allows for iteration over MEDFile DataStructure without any overhead.
4223 * \param [in] mname - a name of a mesh of interest. It can be \c NULL, which is valid
4224 * for the case with only one underlying mesh. (Actually, the number of meshes is
4225 * not checked if \a mname == \c NULL).
4226 * \param [in,out] types - a sequence of types of underlying mesh entities. A type per
4227 * a field part is returned.
4228 * \param [in,out] typesF - a sequence of sequences of types of spatial discretizations.
4229 * This sequence is of the same length as \a types.
4230 * \param [in,out] pfls - a sequence returning a profile name per each type of spatial
4231 * discretization. A profile name can be empty.
4232 * Length of this and of nested sequences is the same as that of \a typesF.
4233 * \param [in,out] locs - a sequence returning a localization name per each type of spatial
4234 * discretization. A localization name can be empty.
4235 * Length of this and of nested sequences is the same as that of \a typesF.
4236 * \return std::vector< std::vector< std::pair<int,int> > > - a sequence holding a range
4237 * of ids of tuples within the data array, per each type of spatial
4238 * discretization within one mesh entity type.
4239 * Length of this and of nested sequences is the same as that of \a typesF.
4240 * \throw If no field is lying on \a mname.
4242 std::vector< std::vector< std::pair<int,int> > > MEDFileAnyTypeField1TSWithoutSDA::getFieldSplitedByType(const std::string& 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
4246 meshId=getMeshIdFromMeshName(mname);
4248 if(_field_per_mesh.empty())
4249 throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getFieldSplitedByType : This is empty !");
4250 return _field_per_mesh[meshId]->getFieldSplitedByType(types,typesF,pfls,locs);
4254 * Returns dimensions of mesh elements \a this field lies on. The returned value is a
4255 * maximal absolute dimension and values returned via the out parameter \a levs are
4256 * dimensions relative to the maximal absolute dimension. <br>
4257 * This method is designed for MEDFileField1TS instances that have a discretization
4258 * \ref MEDCoupling::ON_CELLS "ON_CELLS",
4259 * \ref MEDCoupling::ON_GAUSS_PT "ON_GAUSS_PT",
4260 * \ref MEDCoupling::ON_GAUSS_NE "ON_GAUSS_NE".
4261 * Only these 3 discretizations will be taken into account here. If \a this is
4262 * \ref MEDCoupling::ON_NODES "ON_NODES", -1 is returned and \a levs are empty.<br>
4263 * This method is useful to make the link between the dimension of the underlying mesh
4264 * and the levels of \a this, because it is possible that the highest dimension of \a this
4265 * field is not equal to the dimension of the underlying mesh.
4267 * Let's consider the following case:
4268 * - mesh \a m1 has a meshDimension 3 and has non empty levels [0,-1,-2] with elements
4269 * TETRA4, HEXA8, TRI3 and SEG2.
4270 * - field \a f1 lies on \a m1 and is defined on 3D and 1D elements TETRA4 and SEG2.
4271 * - field \a f2 lies on \a m1 and is defined on 2D and 1D elements TRI3 and SEG2.
4273 * In this case \a f1->getNonEmptyLevels() returns (3,[0,-2]) and \a
4274 * f2->getNonEmptyLevels() returns (2,[0,-1]). <br>
4275 * The returned values can be used for example to retrieve a MEDCouplingFieldDouble lying
4276 * on elements of a certain relative level by calling getFieldAtLevel(). \a meshDimRelToMax
4277 * parameter of getFieldAtLevel() is computed basing on the returned values as this:
4278 * <em> meshDimRelToMax = absDim - meshDim + relativeLev </em>.
4280 * to retrieve the highest level of
4281 * \a f1: <em>f1->getFieldAtLevel( ON_CELLS, 3-3+0 ); // absDim - meshDim + relativeLev</em><br>
4282 * to retrieve the lowest level of \a f1: <em>f1->getFieldAtLevel( ON_CELLS, 3-3+(-2) );</em><br>
4283 * to retrieve the highest level of \a f2: <em>f2->getFieldAtLevel( ON_CELLS, 2-3+0 );</em><br>
4284 * to retrieve the lowest level of \a f2: <em>f2->getFieldAtLevel( ON_CELLS, 2-3+(-1) )</em>.
4285 * \param [in] mname - a name of a mesh of interest. It can be \c NULL, which is valid
4286 * for the case with only one underlying mesh. (Actually, the number of meshes is
4287 * not checked if \a mname == \c NULL).
4288 * \param [in,out] levs - a sequence returning the dimensions relative to the maximal
4289 * absolute one. They are in decreasing order. This sequence is cleared before
4291 * \return int - the maximal absolute dimension of elements \a this fields lies on.
4292 * \throw If no field is lying on \a mname.
4294 int MEDFileAnyTypeField1TSWithoutSDA::getNonEmptyLevels(const std::string& mname, std::vector<int>& levs) const
4297 int meshId=getMeshIdFromMeshName(mname);
4298 std::vector<INTERP_KERNEL::NormalizedCellType> types;
4299 std::vector< std::vector<TypeOfField> > typesF;
4300 std::vector< std::vector<std::string> > pfls, locs;
4301 _field_per_mesh[meshId]->getFieldSplitedByType(types,typesF,pfls,locs);
4303 throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getNonEmptyLevels : 'this' is empty !");
4304 std::set<INTERP_KERNEL::NormalizedCellType> st(types.begin(),types.end());
4305 if(st.size()==1 && (*st.begin())==INTERP_KERNEL::NORM_ERROR)
4307 st.erase(INTERP_KERNEL::NORM_ERROR);
4309 for(std::set<INTERP_KERNEL::NormalizedCellType>::const_iterator it=st.begin();it!=st.end();it++)
4311 const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(*it);
4312 ret1.insert((int)cm.getDimension());
4314 int ret=*std::max_element(ret1.begin(),ret1.end());
4315 std::copy(ret1.rbegin(),ret1.rend(),std::back_insert_iterator<std::vector<int> >(levs));
4316 std::transform(levs.begin(),levs.end(),levs.begin(),std::bind2nd(std::plus<int>(),-ret));
4321 * \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.
4322 * \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.
4323 * \param [in] locId is the localization id to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set. It corresponds to the position of
4324 * \c pfls[std::distance(types.begin(),std::find(types.begin(),typ)] vector in MEDFileField1TSWithoutSDA::getFieldSplitedByType. For non gausspoints field users, the value is 0.
4326 MEDFileFieldPerMeshPerTypePerDisc *MEDFileAnyTypeField1TSWithoutSDA::getLeafGivenMeshAndTypeAndLocId(const std::string& mName, INTERP_KERNEL::NormalizedCellType typ, int locId)
4328 int mid=getMeshIdFromMeshName(mName);
4329 return _field_per_mesh[mid]->getLeafGivenTypeAndLocId(typ,locId);
4333 * \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.
4334 * \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.
4335 * \param [in] locId is the localization id to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set. It corresponds to the position of
4336 * \c pfls[std::distance(types.begin(),std::find(types.begin(),typ)] vector in MEDFileField1TSWithoutSDA::getFieldSplitedByType. For non gausspoints field users, the value is 0.
4338 const MEDFileFieldPerMeshPerTypePerDisc *MEDFileAnyTypeField1TSWithoutSDA::getLeafGivenMeshAndTypeAndLocId(const std::string& mName, INTERP_KERNEL::NormalizedCellType typ, int locId) const
4340 int mid=getMeshIdFromMeshName(mName);
4341 return _field_per_mesh[mid]->getLeafGivenTypeAndLocId(typ,locId);
4345 * \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.
4347 int MEDFileAnyTypeField1TSWithoutSDA::getMeshIdFromMeshName(const std::string& mName) const
4349 if(_field_per_mesh.empty())
4350 throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getMeshIdFromMeshName : No field set !");
4353 std::string mName2(mName);
4355 std::vector<std::string> msg;
4356 for(std::vector< MCAuto< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++,ret++)
4357 if(mName2==(*it)->getMeshName())
4360 msg.push_back((*it)->getMeshName());
4361 std::ostringstream oss; oss << "MEDFileField1TSWithoutSDA::getMeshIdFromMeshName : No such mesh \"" << mName2 << "\" as underlying mesh of field \"" << getName() << "\" !\n";
4362 oss << "Possible meshes are : ";
4363 for(std::vector<std::string>::const_iterator it2=msg.begin();it2!=msg.end();it2++)
4364 oss << "\"" << (*it2) << "\" ";
4365 throw INTERP_KERNEL::Exception(oss.str());
4368 int MEDFileAnyTypeField1TSWithoutSDA::addNewEntryIfNecessary(const MEDCouplingMesh *mesh)
4371 throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::addNewEntryIfNecessary : input mesh is NULL !");
4372 std::string tmp(mesh->getName());
4374 throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::addNewEntryIfNecessary : empty mesh name ! unsupported by MED file !");
4375 std::vector< MCAuto< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();
4377 for(;it!=_field_per_mesh.end();it++,i++)
4379 if((*it)->getMeshName()==tmp)
4382 int sz=_field_per_mesh.size();
4383 _field_per_mesh.resize(sz+1);
4384 _field_per_mesh[sz]=MEDFileFieldPerMesh::New(this,mesh);
4388 bool MEDFileAnyTypeField1TSWithoutSDA::renumberEntitiesLyingOnMesh(const std::string& meshName, const std::vector<int>& oldCode, const std::vector<int>& newCode, const DataArrayInt *renumO2N,
4389 MEDFileFieldGlobsReal& glob)
4392 for(std::vector< MCAuto< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4394 MEDFileFieldPerMesh *fpm(*it);
4396 ret=fpm->renumberEntitiesLyingOnMesh(meshName,oldCode,newCode,renumO2N,glob) || ret;
4402 * This method splits \a this into several sub-parts so that each sub parts have exactly one spatial discretization. This method implements the minimal
4403 * splitting that leads to single spatial discretization of this.
4405 * \sa splitMultiDiscrPerGeoTypes
4407 std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > MEDFileAnyTypeField1TSWithoutSDA::splitDiscretizations() const
4409 std::vector<INTERP_KERNEL::NormalizedCellType> types;
4410 std::vector< std::vector<TypeOfField> > typesF;
4411 std::vector< std::vector<std::string> > pfls,locs;
4412 std::vector< std::vector<std::pair<int,int> > > bgEnd(getFieldSplitedByType(getMeshName().c_str(),types,typesF,pfls,locs));
4413 std::set<TypeOfField> allEnt;
4414 for(std::vector< std::vector<TypeOfField> >::const_iterator it1=typesF.begin();it1!=typesF.end();it1++)
4415 for(std::vector<TypeOfField>::const_iterator it2=(*it1).begin();it2!=(*it1).end();it2++)
4416 allEnt.insert(*it2);
4417 std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > ret(allEnt.size());
4418 std::set<TypeOfField>::const_iterator it3(allEnt.begin());
4419 for(std::size_t i=0;i<allEnt.size();i++,it3++)
4421 std::vector< std::pair<int,int> > its;
4422 ret[i]=shallowCpy();
4423 int newLgth(ret[i]->keepOnlySpatialDiscretization(*it3,its));
4424 ret[i]->updateData(newLgth,its);
4430 * This method performs a sub splitting as splitDiscretizations does but finer. This is the finest spliting level that can be done.
4431 * This method implements the minimal splitting so that each returned elements are mono Gauss discretization per geometric type.
4433 * \sa splitDiscretizations
4435 std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > MEDFileAnyTypeField1TSWithoutSDA::splitMultiDiscrPerGeoTypes() const
4437 std::vector<INTERP_KERNEL::NormalizedCellType> types;
4438 std::vector< std::vector<TypeOfField> > typesF;
4439 std::vector< std::vector<std::string> > pfls,locs;
4440 std::vector< std::vector<std::pair<int,int> > > bgEnd(getFieldSplitedByType(getMeshName().c_str(),types,typesF,pfls,locs));
4441 std::set<TypeOfField> allEnt;
4442 std::size_t nbOfMDPGT(0),ii(0);
4443 for(std::vector< std::vector<TypeOfField> >::const_iterator it1=typesF.begin();it1!=typesF.end();it1++,ii++)
4445 nbOfMDPGT=std::max(nbOfMDPGT,locs[ii].size());
4446 for(std::vector<TypeOfField>::const_iterator it2=(*it1).begin();it2!=(*it1).end();it2++)
4447 allEnt.insert(*it2);
4449 if(allEnt.size()!=1)
4450 throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::splitMultiDiscrPerGeoTypes : this field is expected to be defined only on one spatial discretization !");
4452 throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::splitMultiDiscrPerGeoTypes : empty field !");
4455 std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > ret0(1);
4456 ret0[0]=const_cast<MEDFileAnyTypeField1TSWithoutSDA *>(this); this->incrRef();
4459 std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > ret(nbOfMDPGT);
4460 for(std::size_t i=0;i<nbOfMDPGT;i++)
4462 std::vector< std::pair<int,int> > its;
4463 ret[i]=shallowCpy();
4464 int newLgth(ret[i]->keepOnlyGaussDiscretization(i,its));
4465 ret[i]->updateData(newLgth,its);
4470 int MEDFileAnyTypeField1TSWithoutSDA::keepOnlySpatialDiscretization(TypeOfField tof, std::vector< std::pair<int,int> >& its)
4472 int globalCounter(0);
4473 for(std::vector< MCAuto< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4474 (*it)->keepOnlySpatialDiscretization(tof,globalCounter,its);
4475 return globalCounter;
4478 int MEDFileAnyTypeField1TSWithoutSDA::keepOnlyGaussDiscretization(std::size_t idOfDisc, std::vector< std::pair<int,int> >& its)
4480 int globalCounter(0);
4481 for(std::vector< MCAuto< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4482 (*it)->keepOnlyGaussDiscretization(idOfDisc,globalCounter,its);
4483 return globalCounter;
4486 void MEDFileAnyTypeField1TSWithoutSDA::updateData(int newLgth, const std::vector< std::pair<int,int> >& oldStartStops)
4488 if(_nb_of_tuples_to_be_allocated>=0)
4490 _nb_of_tuples_to_be_allocated=newLgth;
4491 const DataArray *oldArr(getUndergroundDataArray());
4494 MCAuto<DataArray> newArr(createNewEmptyDataArrayInstance());
4495 newArr->setInfoAndChangeNbOfCompo(oldArr->getInfoOnComponents());
4497 _nb_of_tuples_to_be_allocated=newLgth;//force the _nb_of_tuples_to_be_allocated because setArray has been used specialy
4501 if(_nb_of_tuples_to_be_allocated==-1)
4503 if(_nb_of_tuples_to_be_allocated==-2 || _nb_of_tuples_to_be_allocated==-3)
4505 const DataArray *oldArr(getUndergroundDataArray());
4506 if(!oldArr || !oldArr->isAllocated())
4507 throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::updateData : internal error 1 !");
4508 MCAuto<DataArray> newArr(createNewEmptyDataArrayInstance());
4509 newArr->alloc(newLgth,getNumberOfComponents());
4511 newArr->copyStringInfoFrom(*oldArr);
4513 for(std::vector< std::pair<int,int> >::const_iterator it=oldStartStops.begin();it!=oldStartStops.end();it++)
4515 if((*it).second<(*it).first)
4516 throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::updateData : the range in the leaves was invalid !");
4517 newArr->setContigPartOfSelectedValuesSlice(pos,oldArr,(*it).first,(*it).second,1);
4518 pos+=(*it).second-(*it).first;
4523 throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::updateData : internal error 2 !");
4526 void MEDFileAnyTypeField1TSWithoutSDA::writeLL(med_idt fid, const MEDFileWritable& opts, const MEDFileFieldNameScope& nasc) const
4528 if(_field_per_mesh.empty())
4529 throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::writeLL : empty field !");
4530 if(_field_per_mesh.size()>1)
4531 throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::writeLL : In MED3.0 mode in writting mode only ONE underlying mesh supported !");
4532 _field_per_mesh[0]->copyOptionsFrom(opts);
4533 _field_per_mesh[0]->writeLL(fid,nasc);
4537 * This methods returns true is the allocation has been needed leading to a modification of state in \a this->_nb_of_tuples_to_be_allocated.
4538 * If false is returned the memory allocation is not required.
4540 bool MEDFileAnyTypeField1TSWithoutSDA::allocIfNecessaryTheArrayToReceiveDataFromFile()
4542 if(_nb_of_tuples_to_be_allocated>=0)
4544 getOrCreateAndGetArray()->alloc(_nb_of_tuples_to_be_allocated,getNumberOfComponents());
4545 _nb_of_tuples_to_be_allocated=-2;
4548 if(_nb_of_tuples_to_be_allocated==-2 || _nb_of_tuples_to_be_allocated==-3)
4550 if(_nb_of_tuples_to_be_allocated==-1)
4551 throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::allocIfNecessaryTheArrayToReceiveDataFromFile : trying to read from a file an empty instance ! Need to prepare the structure before !");
4552 if(_nb_of_tuples_to_be_allocated<-3)
4553 throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::allocIfNecessaryTheArrayToReceiveDataFromFile : internal error !");
4554 throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::allocIfNecessaryTheArrayToReceiveDataFromFile : internal error !");
4557 void MEDFileAnyTypeField1TSWithoutSDA::loadOnlyStructureOfDataRecursively(med_idt fid, const MEDFileFieldNameScope& nasc, const MEDFileMeshes *ms, const std::vector< std::pair<TypeOfField,INTERP_KERNEL::NormalizedCellType> > *entities)
4559 med_int numdt,numit;
4563 med_int meshnumdt,meshnumit;
4564 INTERP_KERNEL::AutoPtr<char> meshName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
4565 MEDFILESAFECALLERRD0(MEDfieldComputingStepInfo,(fid,nasc.getName().c_str(),_csit,&numdt,&numit,&_dt));
4566 MEDFILESAFECALLERRD0(MEDfield23ComputingStepMeshInfo,(fid,nasc.getName().c_str(),_csit,&numdt,&numit,&dt,&nmesh,meshName,&localMesh,&meshnumdt,&meshnumit));
4567 if(_iteration!=numdt || _order!=numit)
4568 throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::loadBigArraysRecursively : unexpected exception internal error !");
4569 _field_per_mesh.resize(nmesh);
4574 std::string meshNameCpp(MEDLoaderBase::buildStringFromFortran(meshName,MED_NAME_SIZE+1));
4575 mm=ms->getMeshWithName(meshNameCpp);
4578 for(int i=0;i<nmesh;i++)
4579 _field_per_mesh[i]=MEDFileFieldPerMesh::NewOnRead(fid,this,i,meshnumdt,meshnumit,nasc,mm,entities);
4580 _nb_of_tuples_to_be_allocated=0;
4581 for(int i=0;i<nmesh;i++)
4582 _field_per_mesh[i]->loadOnlyStructureOfDataRecursively(fid,_nb_of_tuples_to_be_allocated,nasc);
4585 void MEDFileAnyTypeField1TSWithoutSDA::loadBigArraysRecursively(med_idt fid, const MEDFileFieldNameScope& nasc)
4587 allocIfNecessaryTheArrayToReceiveDataFromFile();
4588 for(std::vector< MCAuto< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4589 (*it)->loadBigArraysRecursively(fid,nasc);
4592 void MEDFileAnyTypeField1TSWithoutSDA::loadBigArraysRecursivelyIfNecessary(med_idt fid, const MEDFileFieldNameScope& nasc)
4594 if(allocIfNecessaryTheArrayToReceiveDataFromFile())
4595 for(std::vector< MCAuto< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4596 (*it)->loadBigArraysRecursively(fid,nasc);
4599 void MEDFileAnyTypeField1TSWithoutSDA::loadStructureAndBigArraysRecursively(med_idt fid, const MEDFileFieldNameScope& nasc, const MEDFileMeshes *ms, const std::vector< std::pair<TypeOfField,INTERP_KERNEL::NormalizedCellType> > *entities)
4601 loadOnlyStructureOfDataRecursively(fid,nasc,ms,entities);
4602 loadBigArraysRecursively(fid,nasc);
4605 void MEDFileAnyTypeField1TSWithoutSDA::unloadArrays()
4607 DataArray *thisArr(getUndergroundDataArray());
4608 if(thisArr && thisArr->isAllocated())
4610 _nb_of_tuples_to_be_allocated=thisArr->getNumberOfTuples();
4611 thisArr->desallocate();
4615 std::size_t MEDFileAnyTypeField1TSWithoutSDA::getHeapMemorySizeWithoutChildren() const
4617 return _dt_unit.capacity()+_field_per_mesh.capacity()*sizeof(MCAuto< MEDFileFieldPerMesh >);
4620 std::vector<const BigMemoryObject *> MEDFileAnyTypeField1TSWithoutSDA::getDirectChildrenWithNull() const
4622 std::vector<const BigMemoryObject *> ret;
4623 if(getUndergroundDataArray())
4624 ret.push_back(getUndergroundDataArray());
4625 for(std::vector< MCAuto< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4626 ret.push_back((const MEDFileFieldPerMesh *)*it);
4631 * Adds a MEDCouplingFieldDouble to \a this. The underlying mesh of the given field is
4632 * checked if its elements are sorted suitable for writing to MED file ("STB" stands for
4633 * "Sort By Type"), if not, an exception is thrown.
4634 * \param [in] field - the field to add to \a this. The array of field \a field is ignored
4635 * \param [in] arr - the array of values.
4636 * \param [in,out] glob - the global data where profiles and localization present in
4637 * \a field, if any, are added.
4638 * \throw If the name of \a field is empty.
4639 * \throw If the data array of \a field is not set.
4640 * \throw If \a this->_arr is already allocated but has different number of components
4642 * \throw If the underlying mesh of \a field has no name.
4643 * \throw If elements in the mesh are not in the order suitable for writing to the MED file.
4645 void MEDFileAnyTypeField1TSWithoutSDA::setFieldNoProfileSBT(const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc)
4647 const MEDCouplingMesh *mesh=field->getMesh();
4649 TypeOfField type=field->getTypeOfField();
4650 std::vector<DataArrayInt *> dummy;
4651 int start=copyTinyInfoFrom(field,arr);
4652 int pos=addNewEntryIfNecessary(mesh);
4655 std::vector<int> code=MEDFileField1TSWithoutSDA::CheckSBTMesh(mesh);
4656 _field_per_mesh[pos]->assignFieldNoProfileNoRenum(start,code,field,arr,glob,nasc);
4659 _field_per_mesh[pos]->assignNodeFieldNoProfile(start,field,arr,glob);
4663 * Adds a MEDCouplingFieldDouble to \a this. Specified entities of a given dimension
4664 * of a given mesh are used as the support of the given field (a real support is not used).
4665 * Elements of the given mesh must be sorted suitable for writing to MED file.
4666 * Order of underlying mesh entities of the given field specified by \a profile parameter
4667 * is not prescribed; this method permutes field values to have them sorted by element
4668 * type as required for writing to MED file. A new profile is added only if no equal
4669 * profile is missing.
4670 * \param [in] field - the field to add to \a this. The field double values are ignored.
4671 * \param [in] arrOfVals - the values of the field \a field used.
4672 * \param [in] mesh - the supporting mesh of \a field.
4673 * \param [in] meshDimRelToMax - a relative dimension of mesh entities \a field lies on.
4674 * \param [in] profile - ids of mesh entities on which corresponding field values lie.
4675 * \param [in,out] glob - the global data where profiles and localization present in
4676 * \a field, if any, are added.
4677 * \throw If either \a field or \a mesh or \a profile has an empty name.
4678 * \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
4679 * \throw If the data array of \a field is not set.
4680 * \throw If \a this->_arr is already allocated but has different number of components
4682 * \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
4683 * \sa setFieldNoProfileSBT()
4685 void MEDFileAnyTypeField1TSWithoutSDA::setFieldProfile(const MEDCouplingFieldDouble *field, const DataArray *arrOfVals, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc)
4688 throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::setFieldProfile : input field is null !");
4689 if(!arrOfVals || !arrOfVals->isAllocated())
4690 throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::setFieldProfile : input array is null or not allocated !");
4691 TypeOfField type=field->getTypeOfField();
4692 std::vector<DataArrayInt *> idsInPflPerType;
4693 std::vector<DataArrayInt *> idsPerType;
4694 std::vector<int> code,code2;
4695 MCAuto<MEDCouplingMesh> m(mesh->getMeshAtLevel(meshDimRelToMax));
4698 m->splitProfilePerType(profile,code,idsInPflPerType,idsPerType);
4699 std::vector< MCAuto<DataArrayInt> > idsInPflPerType2(idsInPflPerType.size()); std::copy(idsInPflPerType.begin(),idsInPflPerType.end(),idsInPflPerType2.begin());
4700 std::vector< MCAuto<DataArrayInt> > idsPerType2(idsPerType.size()); std::copy(idsPerType.begin(),idsPerType.end(),idsPerType2.begin());
4701 std::vector<const DataArrayInt *> idsPerType3(idsPerType.size()); std::copy(idsPerType.begin(),idsPerType.end(),idsPerType3.begin());
4703 MCAuto<MEDCouplingFieldDouble> field2=field->clone(false);
4704 int nbOfTuplesExp=field2->getNumberOfTuplesExpectedRegardingCode(code,idsPerType3);
4705 if(nbOfTuplesExp!=arrOfVals->getNumberOfTuples())
4707 std::ostringstream oss; oss << "MEDFileAnyTypeField1TSWithoutSDA::setFieldProfile : The array is expected to have " << nbOfTuplesExp << " tuples ! It has " << arrOfVals->getNumberOfTuples() << " !";
4708 throw INTERP_KERNEL::Exception(oss.str());
4711 int start=copyTinyInfoFrom(field,arrOfVals);
4712 code2=m->getDistributionOfTypes();
4714 int pos=addNewEntryIfNecessary(m);
4715 _field_per_mesh[pos]->assignFieldProfile(start,profile,code,code2,idsInPflPerType,idsPerType,field,arrOfVals,m,glob,nasc);
4719 if(!profile || !profile->isAllocated() || profile->getNumberOfComponents()!=1)
4720 throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::setFieldProfile : input profile is null, not allocated or with number of components != 1 !");
4721 std::vector<int> v(3); v[0]=-1; v[1]=profile->getNumberOfTuples(); v[2]=0;
4722 std::vector<const DataArrayInt *> idsPerType3(1); idsPerType3[0]=profile;
4723 int nbOfTuplesExp=field->getNumberOfTuplesExpectedRegardingCode(v,idsPerType3);
4724 if(nbOfTuplesExp!=arrOfVals->getNumberOfTuples())
4726 std::ostringstream oss; oss << "MEDFileAnyTypeField1TSWithoutSDA::setFieldProfile : For node field, the array is expected to have " << nbOfTuplesExp << " tuples ! It has " << arrOfVals->getNumberOfTuples() << " !";
4727 throw INTERP_KERNEL::Exception(oss.str());
4729 int start=copyTinyInfoFrom(field,arrOfVals);
4730 int pos=addNewEntryIfNecessary(m);
4731 _field_per_mesh[pos]->assignNodeFieldProfile(start,profile,field,arrOfVals,glob,nasc);
4736 * \param [in] newNbOfTuples - The new nb of tuples to be allocated.
4738 void MEDFileAnyTypeField1TSWithoutSDA::allocNotFromFile(int newNbOfTuples)
4740 if(_nb_of_tuples_to_be_allocated>=0)
4741 throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::allocNotFromFile : the object is expected to be appended to a data coming from a file but not loaded ! Load before appending data !");
4742 DataArray *arr(getOrCreateAndGetArray());
4743 arr->alloc(newNbOfTuples,arr->getNumberOfComponents());
4744 _nb_of_tuples_to_be_allocated=-3;
4748 * Copies tiny info and allocates \a this->_arr instance of DataArrayDouble to
4749 * append data of a given MEDCouplingFieldDouble. So that the size of \a this->_arr becomes
4750 * larger by the size of \a field. Returns an id of the first not filled
4751 * tuple of \a this->_arr.
4752 * \param [in] field - the field to copy the info on components and the name from.
4753 * \return int - the id of first not initialized tuple of \a this->_arr.
4754 * \throw If the name of \a field is empty.
4755 * \throw If the data array of \a field is not set.
4756 * \throw If \a this->_arr is already allocated but has different number of components
4759 int MEDFileAnyTypeField1TSWithoutSDA::copyTinyInfoFrom(const MEDCouplingFieldDouble *field, const DataArray *arr)
4762 throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::copyTinyInfoFrom : input field is NULL !");
4763 std::string name(field->getName());
4764 setName(name.c_str());
4765 setDtUnit(field->getTimeUnit());
4767 throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::copyTinyInfoFrom : unsupported fields with no name in MED file !");
4769 throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::copyTinyInfoFrom : no array set !");
4770 if(!arr->isAllocated())
4771 throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::copyTinyInfoFrom : array is not allocated !");
4772 _dt=field->getTime(_iteration,_order);
4773 getOrCreateAndGetArray()->setInfoAndChangeNbOfCompo(arr->getInfoOnComponents());
4774 if(!getOrCreateAndGetArray()->isAllocated())
4776 allocNotFromFile(arr->getNumberOfTuples());
4781 int oldNbOfTuples=getOrCreateAndGetArray()->getNumberOfTuples();
4782 int newNbOfTuples=oldNbOfTuples+arr->getNumberOfTuples();
4783 getOrCreateAndGetArray()->reAlloc(newNbOfTuples);
4784 _nb_of_tuples_to_be_allocated=-3;
4785 return oldNbOfTuples;
4790 * Returns number of components in \a this field
4791 * \return int - the number of components.
4793 int MEDFileAnyTypeField1TSWithoutSDA::getNumberOfComponents() const
4795 return getOrCreateAndGetArray()->getNumberOfComponents();
4799 * Change info on components in \a this.
4800 * \throw If size of \a infos is not equal to the number of components already in \a this.
4802 void MEDFileAnyTypeField1TSWithoutSDA::setInfo(const std::vector<std::string>& infos)
4804 DataArray *arr=getOrCreateAndGetArray();
4805 arr->setInfoOnComponents(infos);//will throw an exception if number of components mimatches
4809 * Returns info on components of \a this field.
4810 * \return const std::vector<std::string>& - a sequence of strings each being an
4811 * information on _i_-th component.
4813 const std::vector<std::string>& MEDFileAnyTypeField1TSWithoutSDA::getInfo() const
4815 const DataArray *arr=getOrCreateAndGetArray();
4816 return arr->getInfoOnComponents();
4820 * Returns a mutable info on components of \a this field.
4821 * \return std::vector<std::string>& - a sequence of strings each being an
4822 * information on _i_-th component.
4824 std::vector<std::string>& MEDFileAnyTypeField1TSWithoutSDA::getInfo()
4826 DataArray *arr=getOrCreateAndGetArray();
4827 return arr->getInfoOnComponents();
4830 bool MEDFileAnyTypeField1TSWithoutSDA::presenceOfMultiDiscPerGeoType() const
4832 for(std::vector< MCAuto< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4834 const MEDFileFieldPerMesh *fpm(*it);
4837 if(fpm->presenceOfMultiDiscPerGeoType())
4843 MEDCouplingFieldDouble *MEDFileAnyTypeField1TSWithoutSDA::fieldOnMesh(const MEDFileFieldGlobsReal *glob, const MEDFileMesh *mesh, MCAuto<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const
4845 static const char MSG0[]="MEDFileAnyTypeField1TSWithoutSDA::fieldOnMesh : the field is too complex to be able to be extracted with \"field\" method ! Call getFieldOnMeshAtLevel method instead to deal with complexity !";
4846 if(_field_per_mesh.empty())
4847 throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::fieldOnMesh : the field is empty ! Nothing to extract !");
4848 if(_field_per_mesh.size()>1)
4849 throw INTERP_KERNEL::Exception(MSG0);
4850 if(_field_per_mesh[0].isNull())
4851 throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::fieldOnMesh : the field is inconsistent !");
4852 const MEDFileFieldPerMesh *pm(_field_per_mesh[0]);
4853 std::set<TypeOfField> types;
4854 pm->fillTypesOfFieldAvailable(types);
4856 throw INTERP_KERNEL::Exception(MSG0);
4857 TypeOfField type(*types.begin());
4858 int meshDimRelToMax(0);
4863 int myDim(std::numeric_limits<int>::max());
4864 bool isUnique(pm->isUniqueLevel(myDim));
4866 throw INTERP_KERNEL::Exception(MSG0);
4867 meshDimRelToMax=myDim-mesh->getMeshDimension();
4868 if(meshDimRelToMax>0)
4869 throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::fieldOnMesh : the mesh attached to field is not compatible with the field !");
4871 return MEDFileAnyTypeField1TSWithoutSDA::getFieldOnMeshAtLevel(type,meshDimRelToMax,0/*renumPol*/,glob,mesh,arrOut,nasc);
4875 * Returns a new MEDCouplingFieldDouble of given type lying on a given support.
4876 * \param [in] type - a spatial discretization of the new field.
4877 * \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
4878 * \param [in] mName - a name of the supporting mesh.
4879 * \param [in] renumPol - specifies how to permute values of the result field according to
4880 * the optional numbers of cells and nodes, if any. The valid values are
4881 * - 0 - do not permute.
4882 * - 1 - permute cells.
4883 * - 2 - permute nodes.
4884 * - 3 - permute cells and nodes.
4886 * \param [in] glob - the global data storing profiles and localization.
4887 * \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
4888 * caller is to delete this field using decrRef() as it is no more needed.
4889 * \throw If the MED file is not readable.
4890 * \throw If there is no mesh named \a mName in the MED file.
4891 * \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
4892 * \throw If no field of \a this is lying on the mesh \a mName.
4893 * \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
4895 MEDCouplingFieldDouble *MEDFileAnyTypeField1TSWithoutSDA::getFieldAtLevel(TypeOfField type, int meshDimRelToMax, const std::string& mName, int renumPol, const MEDFileFieldGlobsReal *glob, MCAuto<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const
4897 MCAuto<MEDFileMesh> mm;
4899 mm=MEDFileMesh::New(glob->getFileName(),getMeshName().c_str(),getMeshIteration(),getMeshOrder());
4901 mm=MEDFileMesh::New(glob->getFileName(),mName,getMeshIteration(),getMeshOrder());
4902 return MEDFileAnyTypeField1TSWithoutSDA::getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,glob,mm,arrOut,nasc);
4906 * Returns a new MEDCouplingFieldDouble of given type lying on a given support.
4907 * \param [in] type - a spatial discretization of the new field.
4908 * \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
4909 * \param [in] renumPol - specifies how to permute values of the result field according to
4910 * the optional numbers of cells and nodes, if any. The valid values are
4911 * - 0 - do not permute.
4912 * - 1 - permute cells.
4913 * - 2 - permute nodes.
4914 * - 3 - permute cells and nodes.
4916 * \param [in] glob - the global data storing profiles and localization.
4917 * \param [in] mesh - the supporting mesh.
4918 * \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
4919 * caller is to delete this field using decrRef() as it is no more needed.
4920 * \throw If the MED file is not readable.
4921 * \throw If no field of \a this is lying on \a mesh.
4922 * \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
4923 * \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
4925 MEDCouplingFieldDouble *MEDFileAnyTypeField1TSWithoutSDA::getFieldOnMeshAtLevel(TypeOfField type, int meshDimRelToMax, int renumPol, const MEDFileFieldGlobsReal *glob, const MEDFileMesh *mesh, MCAuto<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const
4927 MCAuto<MEDCouplingMesh> m(mesh->getMeshAtLevel(meshDimRelToMax,false));
4928 const DataArrayInt *d(mesh->getNumberFieldAtLevel(meshDimRelToMax)),*e(mesh->getNumberFieldAtLevel(1));
4929 if(meshDimRelToMax==1)
4930 (static_cast<MEDCouplingUMesh *>((MEDCouplingMesh *)m))->setMeshDimension(0);
4931 return MEDFileAnyTypeField1TSWithoutSDA::getFieldOnMeshAtLevel(type,renumPol,glob,m,d,e,arrOut,nasc);
4935 * Returns a new MEDCouplingFieldDouble of a given type lying on the top level cells of a
4937 * \param [in] type - a spatial discretization of the new field.
4938 * \param [in] mName - a name of the supporting mesh.
4939 * \param [in] renumPol - specifies how to permute values of the result field according to
4940 * the optional numbers of cells and nodes, if any. The valid values are
4941 * - 0 - do not permute.
4942 * - 1 - permute cells.
4943 * - 2 - permute nodes.
4944 * - 3 - permute cells and nodes.
4946 * \param [in] glob - the global data storing profiles and localization.
4947 * \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
4948 * caller is to delete this field using decrRef() as it is no more needed.
4949 * \throw If the MED file is not readable.
4950 * \throw If there is no mesh named \a mName in the MED file.
4951 * \throw If there are no mesh entities in the mesh.
4952 * \throw If no field values of the given \a type are available.
4954 MEDCouplingFieldDouble *MEDFileAnyTypeField1TSWithoutSDA::getFieldAtTopLevel(TypeOfField type, const std::string& mName, int renumPol, const MEDFileFieldGlobsReal *glob, MCAuto<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const
4956 MCAuto<MEDFileMesh> mm;
4958 mm=MEDFileMesh::New(glob->getFileName(),getMeshName().c_str(),getMeshIteration(),getMeshOrder());
4960 mm=MEDFileMesh::New(glob->getFileName(),mName,getMeshIteration(),getMeshOrder());
4961 int absDim=getDimension();
4962 int meshDimRelToMax=absDim-mm->getMeshDimension();
4963 return MEDFileAnyTypeField1TSWithoutSDA::getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,glob,mm,arrOut,nasc);
4967 * Returns a new MEDCouplingFieldDouble of given type lying on a given support.
4968 * \param [in] type - a spatial discretization of the new field.
4969 * \param [in] renumPol - specifies how to permute values of the result field according to
4970 * the optional numbers of cells and nodes, if any. The valid values are
4971 * - 0 - do not permute.
4972 * - 1 - permute cells.
4973 * - 2 - permute nodes.
4974 * - 3 - permute cells and nodes.
4976 * \param [in] glob - the global data storing profiles and localization.
4977 * \param [in] mesh - the supporting mesh.
4978 * \param [in] cellRenum - the cell numbers array used for permutation of the result
4979 * field according to \a renumPol.
4980 * \param [in] nodeRenum - the node numbers array used for permutation of the result
4981 * field according to \a renumPol.
4982 * \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
4983 * caller is to delete this field using decrRef() as it is no more needed.
4984 * \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
4985 * \throw If no field of \a this is lying on \a mesh.
4986 * \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
4988 MEDCouplingFieldDouble *MEDFileAnyTypeField1TSWithoutSDA::getFieldOnMeshAtLevel(TypeOfField type, int renumPol, const MEDFileFieldGlobsReal *glob, const MEDCouplingMesh *mesh, const DataArrayInt *cellRenum, const DataArrayInt *nodeRenum, MCAuto<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const
4990 static const char msg1[]="MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel : request for a renumbered field following mesh numbering whereas it is a profile field !";
4991 int meshId=getMeshIdFromMeshName(mesh->getName());
4993 MCAuto<MEDCouplingFieldDouble> ret=_field_per_mesh[meshId]->getFieldOnMeshAtLevel(type,glob,mesh,isPfl,arrOut,nasc);
4998 //no need to test _field_per_mesh.empty() because geMeshName has already done it
5005 throw INTERP_KERNEL::Exception(msg1);
5006 //no need to test _field_per_mesh.empty() because geMeshName has already done it
5009 if((int)cellRenum->getNbOfElems()!=mesh->getNumberOfCells())
5011 std::ostringstream oss; oss << "MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel : Request of simple renumbering but it seems that underlying mesh \"" << mesh->getName() << "\" of requested field ";
5012 oss << "\"" << getName() << "\" has partial renumbering (some geotype has no renumber) !";
5013 throw INTERP_KERNEL::Exception(oss.str());
5015 MEDCouplingFieldDiscretization *disc=ret->getDiscretization();
5016 if(!disc) throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::getFieldOnMeshAtLevel : internal error, no discretization on field !");
5017 std::vector<DataArray *> arrOut2(1,arrOut);
5018 // 2 following lines replace ret->renumberCells(cellRenum->getConstPointer()) if not DataArrayDouble
5019 disc->renumberArraysForCell(ret->getMesh(),arrOut2,cellRenum->getConstPointer(),true);
5020 (const_cast<MEDCouplingMesh*>(ret->getMesh()))->renumberCells(cellRenum->getConstPointer(),true);
5027 //no need to test _field_per_mesh.empty() because geMeshName has already done it
5029 throw INTERP_KERNEL::Exception(msg1);
5032 if((int)nodeRenum->getNbOfElems()!=mesh->getNumberOfNodes())
5034 std::ostringstream oss; oss << "MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel : Request of simple renumbering but it seems that underlying mesh \"" << mesh->getName() << "\" of requested field ";
5035 oss << "\"" << nasc.getName() << "\" not defined on all nodes !";
5036 throw INTERP_KERNEL::Exception(oss.str());
5038 MCAuto<DataArrayInt> nodeRenumSafe=nodeRenum->checkAndPreparePermutation();
5039 if(!dynamic_cast<DataArrayDouble *>((DataArray *)arrOut))
5040 throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel : node renumbering not implemented for not double DataArrays !");
5041 ret->renumberNodes(nodeRenumSafe->getConstPointer());
5046 throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel : unsupported renum policy ! Dealing with policy 0 1 2 and 3 !");
5051 * Returns values and a profile of the field of a given type lying on a given support.
5052 * \param [in] type - a spatial discretization of the field.
5053 * \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
5054 * \param [in] mesh - the supporting mesh.
5055 * \param [out] pfl - a new instance of DataArrayInt holding ids of mesh entities the
5056 * field of interest lies on. If the field lies on all entities of the given
5057 * dimension, all ids in \a pfl are zero. The caller is to delete this array
5058 * using decrRef() as it is no more needed.
5059 * \param [in] glob - the global data storing profiles and localization.
5060 * \return DataArrayDouble * - a new instance of DataArrayDouble holding values of the
5061 * field. The caller is to delete this array using decrRef() as it is no more needed.
5062 * \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
5063 * \throw If no field of \a this is lying on \a mesh.
5064 * \throw If no field values of the given \a type are available.
5066 DataArray *MEDFileAnyTypeField1TSWithoutSDA::getFieldWithProfile(TypeOfField type, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt *&pfl, const MEDFileFieldGlobsReal *glob, const MEDFileFieldNameScope& nasc) const
5068 MCAuto<MEDCouplingMesh> m(mesh->getMeshAtLevel(meshDimRelToMax));
5069 int meshId=getMeshIdFromMeshName(mesh->getName().c_str());
5070 MCAuto<DataArray> ret=_field_per_mesh[meshId]->getFieldOnMeshAtLevelWithPfl(type,m,pfl,glob,nasc);
5071 ret->setName(nasc.getName().c_str());
5075 //= MEDFileField1TSWithoutSDA
5078 * Throws if a given value is not a valid (non-extended) relative dimension.
5079 * \param [in] meshDimRelToMax - the relative dimension value.
5080 * \throw If \a meshDimRelToMax > 0.
5082 void MEDFileField1TSWithoutSDA::CheckMeshDimRel(int meshDimRelToMax)
5084 if(meshDimRelToMax>0)
5085 throw INTERP_KERNEL::Exception("CheckMeshDimRel : This is a meshDimRel not a meshDimRelExt ! So value should be <=0 !");
5089 * Checks if elements of a given mesh are in the order suitable for writing
5090 * to the MED file. If this is not so, an exception is thrown. In a case of success, returns a
5091 * vector describing types of elements and their number.
5092 * \param [in] mesh - the mesh to check.
5093 * \return std::vector<int> - a vector holding for each element type (1) item of
5094 * INTERP_KERNEL::NormalizedCellType, (2) number of elements, (3) -1.
5095 * These values are in full-interlace mode.
5096 * \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
5098 std::vector<int> MEDFileField1TSWithoutSDA::CheckSBTMesh(const MEDCouplingMesh *mesh)
5101 throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::CheckSBTMesh : input mesh is NULL !");
5102 std::set<INTERP_KERNEL::NormalizedCellType> geoTypes=mesh->getAllGeoTypes();
5103 int nbOfTypes=geoTypes.size();
5104 std::vector<int> code(3*nbOfTypes);
5105 MCAuto<DataArrayInt> arr1=DataArrayInt::New();
5106 arr1->alloc(nbOfTypes,1);
5107 int *arrPtr=arr1->getPointer();
5108 std::set<INTERP_KERNEL::NormalizedCellType>::const_iterator it=geoTypes.begin();
5109 for(int i=0;i<nbOfTypes;i++,it++)
5110 arrPtr[i]=std::distance(typmai2,std::find(typmai2,typmai2+MED_N_CELL_FIXED_GEO,*it));
5111 MCAuto<DataArrayInt> arr2=arr1->checkAndPreparePermutation();
5112 const int *arrPtr2=arr2->getConstPointer();
5114 for(it=geoTypes.begin();it!=geoTypes.end();it++,i++)
5117 int nbCells=mesh->getNumberOfCellsWithType(*it);
5118 code[3*pos]=(int)(*it);
5119 code[3*pos+1]=nbCells;
5120 code[3*pos+2]=-1;//no profiles
5122 std::vector<const DataArrayInt *> idsPerType;//no profiles
5123 DataArrayInt *da=mesh->checkTypeConsistencyAndContig(code,idsPerType);
5127 throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::CheckSBTMesh : underlying mesh is not sorted by type as MED file expects !");
5132 MEDFileField1TSWithoutSDA *MEDFileField1TSWithoutSDA::New(const std::string& fieldName, int csit, int iteration, int order, const std::vector<std::string>& infos)
5134 return new MEDFileField1TSWithoutSDA(fieldName,csit,iteration,order,infos);
5138 * Returns all attributes and values of parts of \a this field lying on a given mesh.
5139 * Each part differs from other ones by a type of supporting mesh entity. The _i_-th
5140 * item of every of returned sequences refers to the _i_-th part of \a this field.
5141 * Thus all sequences returned by this method are of the same length equal to number
5142 * of different types of supporting entities.<br>
5143 * A field part can include sub-parts with several different spatial discretizations,
5144 * \ref MEDCoupling::ON_CELLS "ON_CELLS" and \ref MEDCoupling::ON_GAUSS_PT "ON_GAUSS_PT"
5145 * for example. Hence, some of the returned sequences contains nested sequences, and an item
5146 * of a nested sequence corresponds to a type of spatial discretization.<br>
5147 * This method allows for iteration over MEDFile DataStructure with a reduced overhead.
5148 * The overhead is due to selecting values into new instances of DataArrayDouble.
5149 * \param [in] mname - a name of a mesh of interest. It can be \c NULL, which is valid
5150 * for the case with only one underlying mesh. (Actually, the number of meshes is
5151 * not checked if \a mname == \c NULL).
5152 * \param [in,out] types - a sequence of types of underlying mesh entities. A type per
5153 * a field part is returned.
5154 * \param [in,out] typesF - a sequence of sequences of types of spatial discretizations.
5155 * A field part can include sub-parts with several different spatial discretizations,
5156 * \ref MEDCoupling::ON_CELLS "ON_CELLS" and
5157 * \ref MEDCoupling::ON_GAUSS_PT "ON_GAUSS_PT" for example.
5158 * This sequence is of the same length as \a types.
5159 * \param [in,out] pfls - a sequence returning a profile name per each type of spatial
5160 * discretization. A profile name can be empty.
5161 * Length of this and of nested sequences is the same as that of \a typesF.
5162 * \param [in,out] locs - a sequence returning a localization name per each type of spatial
5163 * discretization. A localization name can be empty.
5164 * Length of this and of nested sequences is the same as that of \a typesF.
5165 * \return std::vector< std::vector<DataArrayDouble *> > - a sequence holding arrays of values
5166 * per each type of spatial discretization within one mesh entity type.
5167 * The caller is to delete each DataArrayDouble using decrRef() as it is no more needed.
5168 * Length of this and of nested sequences is the same as that of \a typesF.
5169 * \throw If no field is lying on \a mname.
5171 std::vector< std::vector<DataArrayDouble *> > MEDFileField1TSWithoutSDA::getFieldSplitedByType2(const std::string& 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
5175 meshId=getMeshIdFromMeshName(mname);
5177 if(_field_per_mesh.empty())
5178 throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getFieldSplitedByType : This is empty !");
5179 std::vector< std::vector< std::pair<int,int> > > ret0=_field_per_mesh[meshId]->getFieldSplitedByType(types,typesF,pfls,locs);
5180 int nbOfRet=ret0.size();
5181 std::vector< std::vector<DataArrayDouble *> > ret(nbOfRet);
5182 for(int i=0;i<nbOfRet;i++)
5184 const std::vector< std::pair<int,int> >& p=ret0[i];
5185 int nbOfRet1=p.size();
5186 ret[i].resize(nbOfRet1);
5187 for(int j=0;j<nbOfRet1;j++)
5189 DataArrayDouble *tmp=_arr->selectByTupleIdSafeSlice(p[j].first,p[j].second,1);
5196 const char *MEDFileField1TSWithoutSDA::getTypeStr() const
5201 MEDFileIntField1TSWithoutSDA *MEDFileField1TSWithoutSDA::convertToInt() const
5203 MCAuto<MEDFileIntField1TSWithoutSDA> ret(new MEDFileIntField1TSWithoutSDA);
5204 ret->MEDFileAnyTypeField1TSWithoutSDA::operator =(*this);
5205 ret->deepCpyLeavesFrom(*this);
5206 const DataArrayDouble *arr(_arr);
5209 MCAuto<DataArrayInt> arr2(arr->convertToIntArr());
5210 ret->setArray(arr2);
5216 * Returns a pointer to the underground DataArrayDouble instance and a
5217 * sequence describing parameters of a support of each part of \a this field. The
5218 * caller should not decrRef() the returned DataArrayDouble. This method allows for a
5219 * direct access to the field values. This method is intended for the field lying on one
5221 * \param [in,out] entries - the sequence describing parameters of a support of each
5222 * part of \a this field. Each item of this sequence consists of two parts. The
5223 * first part describes a type of mesh entity and an id of discretization of a
5224 * current field part. The second part describes a range of values [begin,end)
5225 * within the returned array relating to the current field part.
5226 * \return DataArrayDouble * - the pointer to the field values array.
5227 * \throw If the number of underlying meshes is not equal to 1.
5228 * \throw If no field values are available.
5229 * \sa getUndergroundDataArray()
5231 DataArrayDouble *MEDFileField1TSWithoutSDA::getUndergroundDataArrayDoubleExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
5233 if(_field_per_mesh.size()!=1)
5234 throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt : field lies on several meshes, this method has no sense !");
5235 if(_field_per_mesh[0]==0)
5236 throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt : no field specified !");
5237 _field_per_mesh[0]->getUndergroundDataArrayExt(entries);
5238 return getUndergroundDataArrayTemplate();
5242 * Returns a pointer to the underground DataArrayDouble instance and a
5243 * sequence describing parameters of a support of each part of \a this field. The
5244 * caller should not decrRef() the returned DataArrayDouble. This method allows for a
5245 * direct access to the field values. This method is intended for the field lying on one
5247 * \param [in,out] entries - the sequence describing parameters of a support of each
5248 * part of \a this field. Each item of this sequence consists of two parts. The
5249 * first part describes a type of mesh entity and an id of discretization of a
5250 * current field part. The second part describes a range of values [begin,end)
5251 * within the returned array relating to the current field part.
5252 * \return DataArrayDouble * - the pointer to the field values array.
5253 * \throw If the number of underlying meshes is not equal to 1.
5254 * \throw If no field values are available.
5255 * \sa getUndergroundDataArray()
5257 DataArray *MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
5259 return getUndergroundDataArrayDoubleExt(entries);
5262 MEDFileField1TSWithoutSDA::MEDFileField1TSWithoutSDA(const std::string& fieldName, int csit, int iteration, int order, const std::vector<std::string>& infos):MEDFileField1TSTemplateWithoutSDA<double>(fieldName,csit,iteration,order)
5264 DataArrayDouble *arr(getOrCreateAndGetArrayTemplate());
5265 arr->setInfoAndChangeNbOfCompo(infos);
5268 MEDFileField1TSWithoutSDA::MEDFileField1TSWithoutSDA():MEDFileField1TSTemplateWithoutSDA<double>()
5272 MEDFileAnyTypeField1TSWithoutSDA *MEDFileField1TSWithoutSDA::shallowCpy() const
5274 MCAuto<MEDFileField1TSWithoutSDA> ret(new MEDFileField1TSWithoutSDA(*this));
5275 ret->deepCpyLeavesFrom(*this);
5279 MEDFileAnyTypeField1TSWithoutSDA *MEDFileField1TSWithoutSDA::deepCopy() const
5281 MCAuto<MEDFileField1TSWithoutSDA> ret=static_cast<MEDFileField1TSWithoutSDA *>(shallowCpy());
5282 if((const DataArrayDouble *)_arr)
5283 ret->_arr=_arr->deepCopy();
5287 //= MEDFileIntField1TSWithoutSDA
5289 MEDFileIntField1TSWithoutSDA *MEDFileIntField1TSWithoutSDA::New(const std::string& fieldName, int csit, int iteration, int order, const std::vector<std::string>& infos)
5291 return new MEDFileIntField1TSWithoutSDA(fieldName,csit,iteration,order,infos);
5294 MEDFileIntField1TSWithoutSDA::MEDFileIntField1TSWithoutSDA():MEDFileField1TSTemplateWithoutSDA<int>()
5298 MEDFileIntField1TSWithoutSDA::MEDFileIntField1TSWithoutSDA(const std::string& fieldName, int csit, int iteration, int order,
5299 const std::vector<std::string>& infos):MEDFileField1TSTemplateWithoutSDA<int>(fieldName,csit,iteration,order)
5301 DataArrayInt *arr(getOrCreateAndGetArrayTemplate());
5302 arr->setInfoAndChangeNbOfCompo(infos);
5305 const char *MEDFileIntField1TSWithoutSDA::getTypeStr() const
5310 MEDFileField1TSWithoutSDA *MEDFileIntField1TSWithoutSDA::convertToDouble() const
5312 MCAuto<MEDFileField1TSWithoutSDA> ret(new MEDFileField1TSWithoutSDA);
5313 ret->MEDFileAnyTypeField1TSWithoutSDA::operator =(*this);
5314 ret->deepCpyLeavesFrom(*this);
5315 const DataArrayInt *arr(_arr);
5318 MCAuto<DataArrayDouble> arr2(arr->convertToDblArr());
5319 ret->setArray(arr2);
5325 * Returns a pointer to the underground DataArrayInt instance and a
5326 * sequence describing parameters of a support of each part of \a this field. The
5327 * caller should not decrRef() the returned DataArrayInt. This method allows for a
5328 * direct access to the field values. This method is intended for the field lying on one
5330 * \param [in,out] entries - the sequence describing parameters of a support of each
5331 * part of \a this field. Each item of this sequence consists of two parts. The
5332 * first part describes a type of mesh entity and an id of discretization of a
5333 * current field part. The second part describes a range of values [begin,end)
5334 * within the returned array relating to the current field part.
5335 * \return DataArrayInt * - the pointer to the field values array.
5336 * \throw If the number of underlying meshes is not equal to 1.
5337 * \throw If no field values are available.
5338 * \sa getUndergroundDataArray()
5340 DataArray *MEDFileIntField1TSWithoutSDA::getUndergroundDataArrayExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
5342 return getUndergroundDataArrayIntExt(entries);
5346 * Returns a pointer to the underground DataArrayInt instance and a
5347 * sequence describing parameters of a support of each part of \a this field. The
5348 * caller should not decrRef() the returned DataArrayInt. This method allows for a
5349 * direct access to the field values. This method is intended for the field lying on one
5351 * \param [in,out] entries - the sequence describing parameters of a support of each
5352 * part of \a this field. Each item of this sequence consists of two parts. The
5353 * first part describes a type of mesh entity and an id of discretization of a
5354 * current field part. The second part describes a range of values [begin,end)
5355 * within the returned array relating to the current field part.
5356 * \return DataArrayInt * - the pointer to the field values array.
5357 * \throw If the number of underlying meshes is not equal to 1.
5358 * \throw If no field values are available.
5359 * \sa getUndergroundDataArray()
5361 DataArrayInt *MEDFileIntField1TSWithoutSDA::getUndergroundDataArrayIntExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
5363 if(_field_per_mesh.size()!=1)
5364 throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt : field lies on several meshes, this method has no sense !");
5365 if(_field_per_mesh[0]==0)
5366 throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt : no field specified !");
5367 _field_per_mesh[0]->getUndergroundDataArrayExt(entries);
5368 return getUndergroundDataArrayTemplate();
5371 MEDFileAnyTypeField1TSWithoutSDA *MEDFileIntField1TSWithoutSDA::shallowCpy() const
5373 MCAuto<MEDFileIntField1TSWithoutSDA> ret(new MEDFileIntField1TSWithoutSDA(*this));
5374 ret->deepCpyLeavesFrom(*this);
5378 MEDFileAnyTypeField1TSWithoutSDA *MEDFileIntField1TSWithoutSDA::deepCopy() const
5380 MCAuto<MEDFileIntField1TSWithoutSDA> ret=static_cast<MEDFileIntField1TSWithoutSDA *>(shallowCpy());
5381 if((const DataArrayInt *)_arr)
5382 ret->_arr=_arr->deepCopy();
5386 MEDFileAnyTypeField1TS::MEDFileAnyTypeField1TS()
5390 //= MEDFileAnyTypeField1TS
5392 MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeField1TS::BuildContentFrom(med_idt fid, bool loadAll, const MEDFileMeshes *ms)
5394 med_field_type typcha;
5396 std::vector<std::string> infos;
5397 std::string dtunit,fieldName;
5398 LocateField2(fid,0,true,fieldName,typcha,infos,dtunit);
5399 MCAuto<MEDFileAnyTypeField1TSWithoutSDA> ret;
5404 ret=MEDFileField1TSWithoutSDA::New(fieldName.c_str(),-1,-1/*iteration*/,-1/*order*/,std::vector<std::string>());
5409 ret=MEDFileIntField1TSWithoutSDA::New(fieldName.c_str(),-1,-1/*iteration*/,-1/*order*/,std::vector<std::string>());
5414 std::ostringstream oss; oss << "MEDFileAnyTypeField1TS::BuildContentFrom(fid) : file \'" << FileNameFromFID(fid) << "\' contains field with name \'" << fieldName << "\' but the type of the first field is not in [MED_FLOAT64, MED_INT32] !";
5415 throw INTERP_KERNEL::Exception(oss.str());
5418 ret->setDtUnit(dtunit.c_str());
5419 ret->getOrCreateAndGetArray()->setInfoAndChangeNbOfCompo(infos);
5421 med_int numdt,numit;
5423 MEDFILESAFECALLERRD0(MEDfieldComputingStepInfo,(fid,fieldName.c_str(),1,&numdt,&numit,&dt));
5424 ret->setTime(numdt,numit,dt);
5427 ret->loadStructureAndBigArraysRecursively(fid,*((const MEDFileAnyTypeField1TSWithoutSDA*)ret),ms,0);
5429 ret->loadOnlyStructureOfDataRecursively(fid,*((const MEDFileAnyTypeField1TSWithoutSDA*)ret),ms,0);
5433 MEDFileAnyTypeField1TS::MEDFileAnyTypeField1TS(med_idt fid, bool loadAll, const MEDFileMeshes *ms)
5434 try:MEDFileFieldGlobsReal(fid)
5436 _content=BuildContentFrom(fid,loadAll,ms);
5439 catch(INTERP_KERNEL::Exception& e)
5444 MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeField1TS::BuildContentFrom(med_idt fid, const std::string& fieldName, bool loadAll, const MEDFileMeshes *ms)
5446 med_field_type typcha;
5447 std::vector<std::string> infos;
5450 int nbSteps=LocateField(fid,fieldName,iii,typcha,infos,dtunit);
5451 MCAuto<MEDFileAnyTypeField1TSWithoutSDA> ret;
5456 ret=MEDFileField1TSWithoutSDA::New(fieldName,-1,-1/*iteration*/,-1/*order*/,std::vector<std::string>());
5461 ret=MEDFileIntField1TSWithoutSDA::New(fieldName,-1,-1/*iteration*/,-1/*order*/,std::vector<std::string>());
5466 std::ostringstream oss; oss << "MEDFileAnyTypeField1TS::BuildContentFrom(fid,fieldName) : file \'" << FileNameFromFID(fid) << "\' contains field with name \'" << fieldName << "\' but the type of field is not in [MED_FLOAT64, MED_INT32] !";
5467 throw INTERP_KERNEL::Exception(oss.str());
5470 ret->setDtUnit(dtunit.c_str());
5471 ret->getOrCreateAndGetArray()->setInfoAndChangeNbOfCompo(infos);
5475 std::ostringstream oss; oss << "MEDFileField1TS(fid,fieldName) : file \'" << FileNameFromFID(fid) << "\' contains field with name \'" << fieldName << "\' but there is no time steps on it !";
5476 throw INTERP_KERNEL::Exception(oss.str());
5479 med_int numdt,numit;
5481 MEDFILESAFECALLERRD0(MEDfieldComputingStepInfo,(fid,fieldName.c_str(),1,&numdt,&numit,&dt));
5482 ret->setTime(numdt,numit,dt);
5485 ret->loadStructureAndBigArraysRecursively(fid,*((const MEDFileAnyTypeField1TSWithoutSDA*)ret),ms,0);
5487 ret->loadOnlyStructureOfDataRecursively(fid,*((const MEDFileAnyTypeField1TSWithoutSDA*)ret),ms,0);
5491 MEDFileAnyTypeField1TS::MEDFileAnyTypeField1TS(med_idt fid, const std::string& fieldName, bool loadAll, const MEDFileMeshes *ms)
5492 try:MEDFileFieldGlobsReal(fid)
5494 _content=BuildContentFrom(fid,fieldName,loadAll,ms);
5497 catch(INTERP_KERNEL::Exception& e)
5502 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::BuildNewInstanceFromContent(MEDFileAnyTypeField1TSWithoutSDA *c)
5505 throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS::BuildNewInstanceFromContent : empty content in input : unable to build a new instance !");
5506 if(dynamic_cast<const MEDFileField1TSWithoutSDA *>(c))
5508 MCAuto<MEDFileField1TS> ret(MEDFileField1TS::New());
5509 ret->_content=c; c->incrRef();
5512 if(dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(c))
5514 MCAuto<MEDFileIntField1TS> ret(MEDFileIntField1TS::New());
5515 ret->_content=c; c->incrRef();
5518 throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS::BuildNewInstanceFromContent : internal error ! a content of type different from FLOAT64 and INT32 has been built but not intercepted !");
5521 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::BuildNewInstanceFromContent(MEDFileAnyTypeField1TSWithoutSDA *c, med_idt fid)
5523 MEDFileAnyTypeField1TS *ret(BuildNewInstanceFromContent(c));
5524 ret->setFileName(FileNameFromFID(fid));
5528 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::New(const std::string& fileName, bool loadAll)
5530 MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
5531 return New(fid,loadAll);
5534 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::New(med_idt fid, bool loadAll)
5536 MCAuto<MEDFileAnyTypeField1TSWithoutSDA> c(BuildContentFrom(fid,loadAll,0));
5537 MCAuto<MEDFileAnyTypeField1TS> ret(BuildNewInstanceFromContent(c,fid));
5538 ret->loadGlobals(fid);
5542 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::New(const std::string& fileName, const std::string& fieldName, bool loadAll)
5544 MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
5545 return New(fid,fieldName,loadAll);
5548 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::New(med_idt fid, const std::string& fieldName, bool loadAll)
5550 MCAuto<MEDFileAnyTypeField1TSWithoutSDA> c(BuildContentFrom(fid,fieldName,loadAll,0));
5551 MCAuto<MEDFileAnyTypeField1TS> ret(BuildNewInstanceFromContent(c,fid));
5552 ret->loadGlobals(fid);
5556 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::New(const std::string& fileName, const std::string& fieldName, int iteration, int order, bool loadAll)
5558 MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
5559 return New(fid,fieldName,iteration,order,loadAll);
5562 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::New(med_idt fid, const std::string& fieldName, int iteration, int order, bool loadAll)
5564 MCAuto<MEDFileAnyTypeField1TSWithoutSDA> c(BuildContentFrom(fid,fieldName,iteration,order,loadAll,0));
5565 MCAuto<MEDFileAnyTypeField1TS> ret(BuildNewInstanceFromContent(c,fid));
5566 ret->loadGlobals(fid);
5570 MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeField1TS::BuildContentFrom(med_idt fid, const std::string& fieldName, int iteration, int order, bool loadAll, const MEDFileMeshes *ms)
5572 med_field_type typcha;
5573 std::vector<std::string> infos;
5576 int nbOfStep2(LocateField(fid,fieldName,iii,typcha,infos,dtunit));
5577 MCAuto<MEDFileAnyTypeField1TSWithoutSDA> ret;
5582 ret=MEDFileField1TSWithoutSDA::New(fieldName,-1,iteration,order,std::vector<std::string>());
5587 ret=MEDFileIntField1TSWithoutSDA::New(fieldName,-1,iteration,order,std::vector<std::string>());
5592 std::ostringstream oss; oss << "MEDFileAnyTypeField1TS::BuildContentFrom(fid,fieldName,iteration,order) : file \'" << FileNameFromFID(fid) << "\' contains field with name \'" << fieldName << "\' but the type of field is not in [MED_FLOAT64, MED_INT32] !";
5593 throw INTERP_KERNEL::Exception(oss.str());
5596 ret->setDtUnit(dtunit.c_str());
5597 ret->getOrCreateAndGetArray()->setInfoAndChangeNbOfCompo(infos);
5600 std::vector< std::pair<int,int> > dtits(nbOfStep2);
5601 for(int i=0;i<nbOfStep2 && !found;i++)
5603 med_int numdt,numit;
5605 MEDFILESAFECALLERRD0(MEDfieldComputingStepInfo,(fid,fieldName.c_str(),i+1,&numdt,&numit,&dt));
5606 if(numdt==iteration && numit==order)
5612 dtits[i]=std::pair<int,int>(numdt,numit);
5616 std::ostringstream oss; oss << "No such iteration (" << iteration << "," << order << ") in existing field '" << fieldName << "' in file '" << FileNameFromFID(fid) << "' ! Available iterations are : ";
5617 for(std::vector< std::pair<int,int> >::const_iterator iter=dtits.begin();iter!=dtits.end();iter++)
5618 oss << "(" << (*iter).first << "," << (*iter).second << "), ";
5619 throw INTERP_KERNEL::Exception(oss.str());
5622 ret->loadStructureAndBigArraysRecursively(fid,*((const MEDFileAnyTypeField1TSWithoutSDA*)ret),ms,0);
5624 ret->loadOnlyStructureOfDataRecursively(fid,*((const MEDFileAnyTypeField1TSWithoutSDA*)ret),ms,0);
5628 MEDFileAnyTypeField1TS::MEDFileAnyTypeField1TS(med_idt fid, const std::string& fieldName, int iteration, int order, bool loadAll, const MEDFileMeshes *ms)
5629 try:MEDFileFieldGlobsReal(fid)
5631 _content=BuildContentFrom(fid,fieldName,iteration,order,loadAll,ms);
5634 catch(INTERP_KERNEL::Exception& e)
5640 * This constructor is a shallow copy constructor. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
5641 * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
5643 * \warning this is a shallow copy constructor
5645 MEDFileAnyTypeField1TS::MEDFileAnyTypeField1TS(const MEDFileAnyTypeField1TSWithoutSDA& other, bool shallowCopyOfContent)
5647 if(!shallowCopyOfContent)
5649 const MEDFileAnyTypeField1TSWithoutSDA *otherPtr(&other);
5650 otherPtr->incrRef();
5651 _content=const_cast<MEDFileAnyTypeField1TSWithoutSDA *>(otherPtr);
5655 _content=other.shallowCpy();
5659 int MEDFileAnyTypeField1TS::LocateField2(med_idt fid, int fieldIdCFormat, bool checkFieldId, std::string& fieldName, med_field_type& typcha, std::vector<std::string>& infos, std::string& dtunitOut)
5663 int nbFields=MEDnField(fid);
5664 if(fieldIdCFormat>=nbFields)
5666 std::ostringstream oss; oss << "MEDFileAnyTypeField1TS::LocateField2(fileName) : in file \'" << FileNameFromFID(fid) << "\' number of fields is " << nbFields << " ! Trying to request for id " << fieldIdCFormat << " !";
5667 throw INTERP_KERNEL::Exception(oss.str());
5670 int ncomp(MEDfieldnComponent(fid,fieldIdCFormat+1));
5671 INTERP_KERNEL::AutoPtr<char> comp=MEDLoaderBase::buildEmptyString(ncomp*MED_SNAME_SIZE);
5672 INTERP_KERNEL::AutoPtr<char> unit=MEDLoaderBase::buildEmptyString(ncomp*MED_SNAME_SIZE);
5673 INTERP_KERNEL::AutoPtr<char> dtunit=MEDLoaderBase::buildEmptyString(MED_LNAME_SIZE);
5674 INTERP_KERNEL::AutoPtr<char> nomcha=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
5675 INTERP_KERNEL::AutoPtr<char> nomMaa=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
5678 MEDFILESAFECALLERRD0(MEDfieldInfo,(fid,fieldIdCFormat+1,nomcha,nomMaa,&localMesh,&typcha,comp,unit,dtunit,&nbOfStep));
5679 fieldName=MEDLoaderBase::buildStringFromFortran(nomcha,MED_NAME_SIZE);
5680 dtunitOut=MEDLoaderBase::buildStringFromFortran(dtunit,MED_LNAME_SIZE);
5681 infos.clear(); infos.resize(ncomp);
5682 for(int j=0;j<ncomp;j++)
5683 infos[j]=MEDLoaderBase::buildUnionUnit((char *)comp+j*MED_SNAME_SIZE,MED_SNAME_SIZE,(char *)unit+j*MED_SNAME_SIZE,MED_SNAME_SIZE);
5688 * This method throws an INTERP_KERNEL::Exception if \a fieldName field is not in file pointed by \a fid and with name \a fileName.
5691 * \return in case of success the number of time steps available for the field with name \a fieldName.
5693 int MEDFileAnyTypeField1TS::LocateField(med_idt fid, const std::string& fieldName, int& posCFormat, med_field_type& typcha, std::vector<std::string>& infos, std::string& dtunitOut)
5695 int nbFields=MEDnField(fid);
5697 std::vector<std::string> fns(nbFields);
5699 for(int i=0;i<nbFields && !found;i++)
5702 nbOfStep2=LocateField2(fid,i,false,tmp,typcha,infos,dtunitOut);
5704 found=(tmp==fieldName);
5710 std::ostringstream oss; oss << "No such field '" << fieldName << "' in file '" << FileNameFromFID(fid) << "' ! Available fields are : ";
5711 for(std::vector<std::string>::const_iterator it=fns.begin();it!=fns.end();it++)
5712 oss << "\"" << *it << "\" ";
5713 throw INTERP_KERNEL::Exception(oss.str());
5719 * This method as MEDFileField1TSW::setLocNameOnLeaf, is dedicated for advanced user that a want a very fine control on their data structure
5720 * without overhead. This method can be called only regarding information returned by MEDFileField1TSWithoutSDA::getFieldSplitedByType or MEDFileField1TSWithoutSDA::getFieldSplitedByType2.
5721 * This method changes the attribute (here it's profile name) of the leaf datastructure (MEDFileFieldPerMeshPerTypePerDisc instance).
5722 * It is the responsability of the caller to invoke MEDFileFieldGlobs::appendProfile or MEDFileFieldGlobs::getProfile
5723 * to keep a valid instance.
5724 * 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.
5725 * If \b newPflName profile name does not already exist the profile with old name will be renamed with name \b newPflName.
5726 * 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.
5728 * \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.
5729 * \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.
5730 * \param [in] locId is the localization id to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set. It corresponds to the position of
5731 * \c pfls[std::distance(types.begin(),std::find(types.begin(),typ)] vector in MEDFileField1TSWithoutSDA::getFieldSplitedByType. For non gausspoints field users, the value is 0.
5732 * \param [in] newLocName is the new localization name.
5733 * \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.
5734 * If false, an exception will be thrown to force user to change previously the name of the profile with name \b newPflName
5736 void MEDFileAnyTypeField1TS::setProfileNameOnLeaf(const std::string& mName, INTERP_KERNEL::NormalizedCellType typ, int locId, const std::string& newPflName, bool forceRenameOnGlob)
5738 MEDFileFieldPerMeshPerTypePerDisc *disc=getLeafGivenMeshAndTypeAndLocId(mName,typ,locId);
5739 std::string oldPflName=disc->getProfile();
5740 std::vector<std::string> vv=getPflsReallyUsedMulti();
5741 int nbOfOcc=std::count(vv.begin(),vv.end(),oldPflName);
5742 if(forceRenameOnGlob || (!existsPfl(newPflName) && nbOfOcc==1))
5744 disc->setProfile(newPflName);
5745 DataArrayInt *pfl=getProfile(oldPflName.c_str());
5746 pfl->setName(newPflName);
5750 std::ostringstream oss; oss << "MEDFileField1TS::setProfileNameOnLeaf : Profile \"" << newPflName << "\" already exists or referenced more than one !";
5751 throw INTERP_KERNEL::Exception(oss.str());
5756 * This method as MEDFileField1TSW::setProfileNameOnLeaf, is dedicated for advanced user that a want a very fine control on their data structure
5757 * without overhead. This method can be called only regarding information returned by MEDFileField1TSWithoutSDA::getFieldSplitedByType or MEDFileField1TSWithoutSDA::getFieldSplitedByType2.
5758 * This method changes the attribute (here it's localization name) of the leaf datastructure (MEDFileFieldPerMeshPerTypePerDisc instance).
5759 * It is the responsability of the caller to invoke MEDFileFieldGlobs::appendProfile or MEDFileFieldGlobs::getProfile
5760 * to keep a valid instance.
5761 * 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.
5762 * This method is an extension of MEDFileField1TSWithoutSDA::setProfileNameOnLeafExt method because it performs a modification of global info.
5763 * If \b newLocName profile name does not already exist the localization with old name will be renamed with name \b newLocName.
5764 * 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.
5766 * \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.
5767 * \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.
5768 * \param [in] locId is the localization id to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set. It corresponds to the position of
5769 * \c pfls[std::distance(types.begin(),std::find(types.begin(),typ)] vector in MEDFileField1TSWithoutSDA::getFieldSplitedByType. For non gausspoints field users, the value is 0.
5770 * \param [in] newLocName is the new localization name.
5771 * \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.
5772 * If false, an exception will be thrown to force user to change previously the name of the profile with name \b newLocName
5774 void MEDFileAnyTypeField1TS::setLocNameOnLeaf(const std::string& mName, INTERP_KERNEL::NormalizedCellType typ, int locId, const std::string& newLocName, bool forceRenameOnGlob)
5776 MEDFileFieldPerMeshPerTypePerDisc *disc=getLeafGivenMeshAndTypeAndLocId(mName,typ,locId);
5777 std::string oldLocName=disc->getLocalization();
5778 std::vector<std::string> vv=getLocsReallyUsedMulti();
5779 int nbOfOcc=std::count(vv.begin(),vv.end(),oldLocName);
5780 if(forceRenameOnGlob || (!existsLoc(newLocName) && nbOfOcc==1))
5782 disc->setLocalization(newLocName);
5783 MEDFileFieldLoc& loc=getLocalization(oldLocName.c_str());
5784 loc.setName(newLocName);
5788 std::ostringstream oss; oss << "MEDFileField1TS::setLocNameOnLeaf : Localization \"" << newLocName << "\" already exists or referenced more than one !";
5789 throw INTERP_KERNEL::Exception(oss.str());
5793 MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeField1TS::contentNotNullBase()
5795 MEDFileAnyTypeField1TSWithoutSDA *ret=_content;
5797 throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS : content is expected to be not null !");
5801 const MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeField1TS::contentNotNullBase() const
5803 const MEDFileAnyTypeField1TSWithoutSDA *ret=_content;
5805 throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS : const content is expected to be not null !");
5810 * This method alloc the arrays and load potentially huge arrays contained in this field.
5811 * This method should be called when a MEDFileAnyTypeField1TS::New constructor has been with false as the last parameter.
5812 * This method can be also called to refresh or reinit values from a file.
5814 * \throw If the fileName is not set or points to a non readable MED file.
5815 * \sa MEDFileAnyTypeField1TS::loadArraysIfNecessary
5817 void MEDFileAnyTypeField1TS::loadArrays()
5819 if(getFileName().empty())
5820 throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS::loadArrays : the structure does not come from a file !");
5821 MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(getFileName()));
5822 contentNotNullBase()->loadBigArraysRecursively(fid,*contentNotNullBase());
5826 * This method behaves as MEDFileAnyTypeField1TS::loadArrays does, the first call, if \a this was built using a file without loading big arrays.
5827 * But once data loaded once, this method does nothing. Contrary to MEDFileAnyTypeField1TS::loadArrays and MEDFileAnyTypeField1TS::unloadArrays
5828 * this method does not throw if \a this does not come from file read.
5830 * \sa MEDFileAnyTypeField1TS::loadArrays, MEDFileAnyTypeField1TS::unloadArrays
5832 void MEDFileAnyTypeField1TS::loadArraysIfNecessary()
5834 if(!getFileName().empty())
5836 MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(getFileName()));
5837 contentNotNullBase()->loadBigArraysRecursivelyIfNecessary(fid,*contentNotNullBase());
5842 * This method releases potentially big data arrays and so returns to the same heap memory than status loaded with 'loadAll' parameter set to false.
5843 * \b WARNING, this method does release arrays even if \a this does not come from a load of a MED file.
5844 * So this method can lead to a loss of data. If you want to unload arrays safely call MEDFileAnyTypeField1TS::unloadArraysWithoutDataLoss instead.
5846 * \sa MEDFileAnyTypeField1TS::loadArrays, MEDFileAnyTypeField1TS::loadArraysIfNecessary, MEDFileAnyTypeField1TS::unloadArraysWithoutDataLoss
5848 void MEDFileAnyTypeField1TS::unloadArrays()
5850 contentNotNullBase()->unloadArrays();
5854 * 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.
5855 * This method is the symetrical method of MEDFileAnyTypeField1TS::loadArraysIfNecessary.
5856 * This method is useful to reduce \b safely amount of heap memory necessary for \a this by using MED file as database.
5858 * \sa MEDFileAnyTypeField1TS::loadArraysIfNecessary
5860 void MEDFileAnyTypeField1TS::unloadArraysWithoutDataLoss()
5862 if(!getFileName().empty())
5863 contentNotNullBase()->unloadArrays();
5866 void MEDFileAnyTypeField1TS::writeLL(med_idt fid) const
5868 int nbComp(getNumberOfComponents());
5869 INTERP_KERNEL::AutoPtr<char> comp(MEDLoaderBase::buildEmptyString(nbComp*MED_SNAME_SIZE));
5870 INTERP_KERNEL::AutoPtr<char> unit(MEDLoaderBase::buildEmptyString(nbComp*MED_SNAME_SIZE));
5871 for(int i=0;i<nbComp;i++)
5873 std::string info=getInfo()[i];
5875 MEDLoaderBase::splitIntoNameAndUnit(info,c,u);
5876 MEDLoaderBase::safeStrCpy2(c.c_str(),MED_SNAME_SIZE,comp+i*MED_SNAME_SIZE,_too_long_str);
5877 MEDLoaderBase::safeStrCpy2(u.c_str(),MED_SNAME_SIZE,unit+i*MED_SNAME_SIZE,_too_long_str);
5879 if(getName().empty())
5880 throw INTERP_KERNEL::Exception("MEDFileField1TS::write : MED file does not accept field with empty name !");
5881 MEDFILESAFECALLERWR0(MEDfieldCr,(fid,getName().c_str(),getMEDFileFieldType(),nbComp,comp,unit,getDtUnit().c_str(),getMeshName().c_str()));
5882 writeGlobals(fid,*this);
5883 contentNotNullBase()->writeLL(fid,*this,*contentNotNullBase());
5886 std::size_t MEDFileAnyTypeField1TS::getHeapMemorySizeWithoutChildren() const
5888 return MEDFileFieldGlobsReal::getHeapMemorySizeWithoutChildren();
5891 std::vector<const BigMemoryObject *> MEDFileAnyTypeField1TS::getDirectChildrenWithNull() const
5893 std::vector<const BigMemoryObject *> ret(MEDFileFieldGlobsReal::getDirectChildrenWithNull());
5894 ret.push_back((const MEDFileAnyTypeField1TSWithoutSDA *)_content);
5899 * Returns a string describing \a this field. This string is outputted
5900 * by \c print Python command.
5902 std::string MEDFileAnyTypeField1TS::simpleRepr() const
5904 std::ostringstream oss;
5905 contentNotNullBase()->simpleRepr(0,oss,-1);
5906 simpleReprGlobs(oss);
5911 * This method returns all profiles whose name is non empty used.
5912 * \b WARNING If profile is used several times it will be reported \b only \b once.
5913 * To get non empty name profiles as time as they appear in \b this call MEDFileField1TS::getPflsReallyUsedMulti instead.
5915 std::vector<std::string> MEDFileAnyTypeField1TS::getPflsReallyUsed() const
5917 return contentNotNullBase()->getPflsReallyUsed2();
5921 * This method returns all localizations whose name is non empty used.
5922 * \b WARNING If localization is used several times it will be reported \b only \b once.
5924 std::vector<std::string> MEDFileAnyTypeField1TS::getLocsReallyUsed() const
5926 return contentNotNullBase()->getLocsReallyUsed2();
5930 * This method returns all profiles whose name is non empty used.
5931 * \b WARNING contrary to MEDFileField1TS::getPflsReallyUsed, if profile is used several times it will be reported as time as it appears.
5933 std::vector<std::string> MEDFileAnyTypeField1TS::getPflsReallyUsedMulti() const
5935 return contentNotNullBase()->getPflsReallyUsedMulti2();
5939 * This method returns all localizations whose name is non empty used.
5940 * \b WARNING contrary to MEDFileField1TS::getLocsReallyUsed if localization is used several times it will be reported as time as it appears.
5942 std::vector<std::string> MEDFileAnyTypeField1TS::getLocsReallyUsedMulti() const
5944 return contentNotNullBase()->getLocsReallyUsedMulti2();
5947 void MEDFileAnyTypeField1TS::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
5949 contentNotNullBase()->changePflsRefsNamesGen2(mapOfModif);
5952 void MEDFileAnyTypeField1TS::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
5954 contentNotNullBase()->changeLocsRefsNamesGen2(mapOfModif);
5957 int MEDFileAnyTypeField1TS::getDimension() const
5959 return contentNotNullBase()->getDimension();
5962 int MEDFileAnyTypeField1TS::getIteration() const
5964 return contentNotNullBase()->getIteration();
5967 int MEDFileAnyTypeField1TS::getOrder() const
5969 return contentNotNullBase()->getOrder();
5972 double MEDFileAnyTypeField1TS::getTime(int& iteration, int& order) const
5974 return contentNotNullBase()->getTime(iteration,order);
5977 void MEDFileAnyTypeField1TS::setTime(int iteration, int order, double val)
5979 contentNotNullBase()->setTime(iteration,order,val);
5982 std::string MEDFileAnyTypeField1TS::getName() const
5984 return contentNotNullBase()->getName();
5987 void MEDFileAnyTypeField1TS::setName(const std::string& name)
5989 contentNotNullBase()->setName(name);
5992 void MEDFileAnyTypeField1TS::simpleRepr(int bkOffset, std::ostream& oss, int f1tsId) const
5994 contentNotNullBase()->simpleRepr(bkOffset,oss,f1tsId);
5997 std::string MEDFileAnyTypeField1TS::getDtUnit() const
5999 return contentNotNullBase()->getDtUnit();
6002 void MEDFileAnyTypeField1TS::setDtUnit(const std::string& dtUnit)
6004 contentNotNullBase()->setDtUnit(dtUnit);
6007 std::string MEDFileAnyTypeField1TS::getMeshName() const
6009 return contentNotNullBase()->getMeshName();
6012 void MEDFileAnyTypeField1TS::setMeshName(const std::string& newMeshName)
6014 contentNotNullBase()->setMeshName(newMeshName);
6017 bool MEDFileAnyTypeField1TS::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab)
6019 return contentNotNullBase()->changeMeshNames(modifTab);
6022 int MEDFileAnyTypeField1TS::getMeshIteration() const
6024 return contentNotNullBase()->getMeshIteration();
6027 int MEDFileAnyTypeField1TS::getMeshOrder() const
6029 return contentNotNullBase()->getMeshOrder();
6032 int MEDFileAnyTypeField1TS::getNumberOfComponents() const
6034 return contentNotNullBase()->getNumberOfComponents();
6037 bool MEDFileAnyTypeField1TS::isDealingTS(int iteration, int order) const
6039 return contentNotNullBase()->isDealingTS(iteration,order);
6042 std::pair<int,int> MEDFileAnyTypeField1TS::getDtIt() const
6044 return contentNotNullBase()->getDtIt();
6047 void MEDFileAnyTypeField1TS::fillIteration(std::pair<int,int>& p) const
6049 contentNotNullBase()->fillIteration(p);
6052 void MEDFileAnyTypeField1TS::fillTypesOfFieldAvailable(std::vector<TypeOfField>& types) const
6054 contentNotNullBase()->fillTypesOfFieldAvailable(types);
6057 void MEDFileAnyTypeField1TS::setInfo(const std::vector<std::string>& infos)
6059 contentNotNullBase()->setInfo(infos);
6062 const std::vector<std::string>& MEDFileAnyTypeField1TS::getInfo() const
6064 return contentNotNullBase()->getInfo();
6066 std::vector<std::string>& MEDFileAnyTypeField1TS::getInfo()
6068 return contentNotNullBase()->getInfo();
6071 bool MEDFileAnyTypeField1TS::presenceOfMultiDiscPerGeoType() const
6073 return contentNotNullBase()->presenceOfMultiDiscPerGeoType();
6076 MEDFileFieldPerMeshPerTypePerDisc *MEDFileAnyTypeField1TS::getLeafGivenMeshAndTypeAndLocId(const std::string& mName, INTERP_KERNEL::NormalizedCellType typ, int locId)
6078 return contentNotNullBase()->getLeafGivenMeshAndTypeAndLocId(mName,typ,locId);
6081 const MEDFileFieldPerMeshPerTypePerDisc *MEDFileAnyTypeField1TS::getLeafGivenMeshAndTypeAndLocId(const std::string& mName, INTERP_KERNEL::NormalizedCellType typ, int locId) const
6083 return contentNotNullBase()->getLeafGivenMeshAndTypeAndLocId(mName,typ,locId);
6086 int MEDFileAnyTypeField1TS::getNonEmptyLevels(const std::string& mname, std::vector<int>& levs) const
6088 return contentNotNullBase()->getNonEmptyLevels(mname,levs);
6091 std::vector<TypeOfField> MEDFileAnyTypeField1TS::getTypesOfFieldAvailable() const
6093 return contentNotNullBase()->getTypesOfFieldAvailable();
6096 std::vector< std::vector<std::pair<int,int> > > MEDFileAnyTypeField1TS::getFieldSplitedByType(const std::string& mname, std::vector<INTERP_KERNEL::NormalizedCellType>& types, std::vector< std::vector<TypeOfField> >& typesF,
6097 std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> >& locs) const
6099 return contentNotNullBase()->getFieldSplitedByType(mname,types,typesF,pfls,locs);
6103 * This method returns as MEDFileAnyTypeField1TS new instances as number of components in \a this.
6104 * The returned instances are deep copy of \a this except that for globals that are share with those contained in \a this.
6105 * ** WARNING ** do no forget to rename the ouput instances to avoid to write n-times in the same MED file field !
6107 std::vector< MCAuto< MEDFileAnyTypeField1TS > > MEDFileAnyTypeField1TS::splitComponents() const
6109 const MEDFileAnyTypeField1TSWithoutSDA *content(_content);
6111 throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS::splitComponents : no content in this ! Unable to split components !");
6112 std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > contentsSplit=content->splitComponents();
6113 std::size_t sz(contentsSplit.size());
6114 std::vector< MCAuto< MEDFileAnyTypeField1TS > > ret(sz);
6115 for(std::size_t i=0;i<sz;i++)
6117 ret[i]=shallowCpy();
6118 ret[i]->_content=contentsSplit[i];
6124 * This method returns as MEDFileAnyTypeField1TS new instances as number of spatial discretizations in \a this.
6125 * The returned instances are shallowed copied of \a this except that for globals that are share with those contained in \a this.
6127 std::vector< MCAuto< MEDFileAnyTypeField1TS > > MEDFileAnyTypeField1TS::splitDiscretizations() const
6129 const MEDFileAnyTypeField1TSWithoutSDA *content(_content);
6131 throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS::splitDiscretizations : no content in this ! Unable to split discretization !");
6132 std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > contentsSplit(content->splitDiscretizations());
6133 std::size_t sz(contentsSplit.size());
6134 std::vector< MCAuto< MEDFileAnyTypeField1TS > > ret(sz);
6135 for(std::size_t i=0;i<sz;i++)
6137 ret[i]=shallowCpy();
6138 ret[i]->_content=contentsSplit[i];
6144 * This method returns as MEDFileAnyTypeField1TS new instances as number of maximal number of discretization in \a this.
6145 * The returned instances are shallowed copied of \a this except that for globals that are share with those contained in \a this.
6147 std::vector< MCAuto< MEDFileAnyTypeField1TS > > MEDFileAnyTypeField1TS::splitMultiDiscrPerGeoTypes() const
6149 const MEDFileAnyTypeField1TSWithoutSDA *content(_content);
6151 throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS::splitMultiDiscrPerGeoTypes : no content in this ! Unable to split discretization !");
6152 std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > contentsSplit(content->splitMultiDiscrPerGeoTypes());
6153 std::size_t sz(contentsSplit.size());
6154 std::vector< MCAuto< MEDFileAnyTypeField1TS > > ret(sz);
6155 for(std::size_t i=0;i<sz;i++)
6157 ret[i]=shallowCpy();
6158 ret[i]->_content=contentsSplit[i];
6163 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::deepCopy() const
6165 MCAuto<MEDFileAnyTypeField1TS> ret=shallowCpy();
6166 if((const MEDFileAnyTypeField1TSWithoutSDA *)_content)
6167 ret->_content=_content->deepCopy();
6168 ret->deepCpyGlobs(*this);
6172 int MEDFileAnyTypeField1TS::copyTinyInfoFrom(const MEDCouplingFieldDouble *field, const DataArray *arr)
6174 return contentNotNullBase()->copyTinyInfoFrom(field,arr);
6180 * Returns a new instance of MEDFileField1TS holding data of the first time step of
6181 * the first field that has been read from a specified MED file.
6182 * \param [in] fileName - the name of the MED file to read.
6183 * \return MEDFileField1TS * - a new instance of MEDFileFieldMultiTS. The caller
6184 * is to delete this field using decrRef() as it is no more needed.
6185 * \throw If reading the file fails.
6187 MEDFileField1TS *MEDFileField1TS::New(const std::string& fileName, bool loadAll)
6189 MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
6190 return New(fid,loadAll);
6193 MEDFileField1TS *MEDFileField1TS::New(med_idt fid, bool loadAll)
6195 MCAuto<MEDFileField1TS> ret(new MEDFileField1TS(fid,loadAll,0));
6196 ret->contentNotNull();
6201 * Returns a new instance of MEDFileField1TS holding data of the first time step of
6202 * a given field that has been read from a specified MED file.
6203 * \param [in] fileName - the name of the MED file to read.
6204 * \param [in] fieldName - the name of the field to read.
6205 * \return MEDFileField1TS * - a new instance of MEDFileFieldMultiTS. The caller
6206 * is to delete this field using decrRef() as it is no more needed.
6207 * \throw If reading the file fails.
6208 * \throw If there is no field named \a fieldName in the file.
6210 MEDFileField1TS *MEDFileField1TS::New(const std::string& fileName, const std::string& fieldName, bool loadAll)
6212 MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
6213 return New(fid,fieldName,loadAll);
6216 MEDFileField1TS *MEDFileField1TS::New(med_idt fid, const std::string& fieldName, bool loadAll)
6218 MCAuto<MEDFileField1TS> ret(new MEDFileField1TS(fid,fieldName,loadAll,0));
6219 ret->contentNotNull();
6224 * Returns a new instance of MEDFileField1TS holding data of a given time step of
6225 * a given field that has been read from a specified MED file.
6226 * \param [in] fileName - the name of the MED file to read.
6227 * \param [in] fieldName - the name of the field to read.
6228 * \param [in] iteration - the iteration number of a required time step.
6229 * \param [in] order - the iteration order number of required time step.
6230 * \return MEDFileField1TS * - a new instance of MEDFileFieldMultiTS. The caller
6231 * is to delete this field using decrRef() as it is no more needed.
6232 * \throw If reading the file fails.
6233 * \throw If there is no field named \a fieldName in the file.
6234 * \throw If the required time step is missing from the file.
6236 MEDFileField1TS *MEDFileField1TS::New(const std::string& fileName, const std::string& fieldName, int iteration, int order, bool loadAll)
6238 MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
6239 return New(fid,fieldName,iteration,order,loadAll);
6242 MEDFileField1TS *MEDFileField1TS::New(med_idt fid, const std::string& fieldName, int iteration, int order, bool loadAll)
6244 MCAuto<MEDFileField1TS> ret(new MEDFileField1TS(fid,fieldName,iteration,order,loadAll,0));
6245 ret->contentNotNull();
6250 * Returns a new instance of MEDFileField1TS. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
6251 * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
6253 * Returns a new instance of MEDFileField1TS holding either a shallow copy
6254 * of a given MEDFileField1TSWithoutSDA ( \a other ) or \a other itself.
6255 * \warning this is a shallow copy constructor
6256 * \param [in] other - a MEDFileField1TSWithoutSDA to copy.
6257 * \param [in] shallowCopyOfContent - if \c true, a shallow copy of \a other is created.
6258 * \return MEDFileField1TS * - a new instance of MEDFileField1TS. The caller
6259 * is to delete this field using decrRef() as it is no more needed.
6261 MEDFileField1TS *MEDFileField1TS::New(const MEDFileField1TSWithoutSDA& other, bool shallowCopyOfContent)
6263 MCAuto<MEDFileField1TS> ret(new MEDFileField1TS(other,shallowCopyOfContent));
6264 ret->contentNotNull();
6269 * Returns a new empty instance of MEDFileField1TS.
6270 * \return MEDFileField1TS * - a new instance of MEDFileField1TS. The caller
6271 * is to delete this field using decrRef() as it is no more needed.
6273 MEDFileField1TS *MEDFileField1TS::New()
6275 MCAuto<MEDFileField1TS> ret(new MEDFileField1TS);
6276 ret->contentNotNull();
6281 * This method performs a copy with datatype modification ( float64->int32 ) of \a this. The globals information are copied
6282 * following the given input policy.
6284 * \param [in] isDeepCpyGlobs - a boolean that indicates the behaviour concerning globals (profiles and localizations)
6285 * By default (true) the globals are deeply copied.
6286 * \return MEDFileIntField1TS * - a new object that is the result of the conversion of \a this to int32 field.
6288 MEDFileIntField1TS *MEDFileField1TS::convertToInt(bool isDeepCpyGlobs) const
6290 MCAuto<MEDFileIntField1TS> ret;
6291 const MEDFileAnyTypeField1TSWithoutSDA *content(_content);
6294 const MEDFileField1TSWithoutSDA *contc=dynamic_cast<const MEDFileField1TSWithoutSDA *>(content);
6296 throw INTERP_KERNEL::Exception("MEDFileField1TS::convertToInt : the content inside this is not FLOAT64 ! This is incoherent !");
6297 MCAuto<MEDFileIntField1TSWithoutSDA> newc(contc->convertToInt());
6298 ret=static_cast<MEDFileIntField1TS *>(MEDFileAnyTypeField1TS::BuildNewInstanceFromContent((MEDFileIntField1TSWithoutSDA *)newc));
6301 ret=MEDFileIntField1TS::New();
6303 ret->deepCpyGlobs(*this);
6305 ret->shallowCpyGlobs(*this);
6309 const MEDFileField1TSWithoutSDA *MEDFileField1TS::contentNotNull() const
6311 const MEDFileAnyTypeField1TSWithoutSDA *pt(_content);
6313 throw INTERP_KERNEL::Exception("MEDFileField1TS::contentNotNull : the content pointer is null !");
6314 const MEDFileField1TSWithoutSDA *ret=dynamic_cast<const MEDFileField1TSWithoutSDA *>(pt);
6316 throw INTERP_KERNEL::Exception("MEDFileField1TS::contentNotNull : the content pointer is not null but it is not of type double ! Reason is maybe that the read field has not the type FLOAT64 !");
6320 MEDFileField1TSWithoutSDA *MEDFileField1TS::contentNotNull()
6322 MEDFileAnyTypeField1TSWithoutSDA *pt(_content);
6324 throw INTERP_KERNEL::Exception("MEDFileField1TS::contentNotNull : the non const content pointer is null !");
6325 MEDFileField1TSWithoutSDA *ret=dynamic_cast<MEDFileField1TSWithoutSDA *>(pt);
6327 throw INTERP_KERNEL::Exception("MEDFileField1TS::contentNotNull : the non const content pointer is not null but it is not of type double ! Reason is maybe that the read field has not the type FLOAT64 !");
6331 void MEDFileField1TS::SetDataArrayDoubleInField(MEDCouplingFieldDouble *f, MCAuto<DataArray>& arr)
6334 throw INTERP_KERNEL::Exception("MEDFileField1TS::SetDataArrayDoubleInField : input field is NULL !");
6336 throw INTERP_KERNEL::Exception("MEDFileField1TS::SetDataArrayDoubleInField : no array !");
6337 DataArrayDouble *arrOutC(dynamic_cast<DataArrayDouble *>((DataArray*)arr));
6339 throw INTERP_KERNEL::Exception("MEDFileField1TS::SetDataArrayDoubleInField : mismatch between dataArrays type and MEDFileField1TS ! Expected double !");
6340 f->setArray(arrOutC);
6343 DataArrayDouble *MEDFileField1TS::ReturnSafelyDataArrayDouble(MCAuto<DataArray>& arr)
6346 throw INTERP_KERNEL::Exception("MEDFileField1TS::ReturnSafelyDataArrayDouble : no array !");
6347 DataArrayDouble *arrOutC(dynamic_cast<DataArrayDouble *>((DataArray*)arr));
6349 throw INTERP_KERNEL::Exception("MEDFileField1TS::ReturnSafelyDataArrayDouble : mismatch between dataArrays type and MEDFileField1TS ! Expected double !");
6355 * Return an extraction of \a this using \a extractDef map to specify the extraction.
6356 * The keys of \a extractDef is level relative to max ext of \a mm mesh.
6358 * \return A new object that the caller is responsible to deallocate.
6359 * \sa MEDFileUMesh::deduceNodeSubPartFromCellSubPart , MEDFileUMesh::extractPart
6361 MEDFileField1TS *MEDFileField1TS::extractPart(const std::map<int, MCAuto<DataArrayInt> >& extractDef, MEDFileMesh *mm) const
6364 throw INTERP_KERNEL::Exception("MEDFileField1TS::extractPart : input mesh is NULL !");
6365 MCAuto<MEDFileField1TS> ret(MEDFileField1TS::New());
6366 std::vector<TypeOfField> tof(getTypesOfFieldAvailable());
6367 for(std::vector<TypeOfField>::const_iterator it0=tof.begin();it0!=tof.end();it0++)
6369 if((*it0)!=ON_NODES)
6371 std::vector<int> levs;
6372 getNonEmptyLevels(mm->getName(),levs);
6373 for(std::vector<int>::const_iterator lev=levs.begin();lev!=levs.end();lev++)
6375 std::map<int, MCAuto<DataArrayInt> >::const_iterator it2(extractDef.find(*lev));
6376 if(it2!=extractDef.end())
6378 MCAuto<DataArrayInt> t((*it2).second);
6380 throw INTERP_KERNEL::Exception("MEDFileField1TS::extractPart : presence of a value with null pointer 1 !");
6381 MCAuto<MEDCouplingFieldDouble> f(getFieldOnMeshAtLevel(ON_CELLS,(*lev),mm));
6382 MCAuto<MEDCouplingFieldDouble> fOut(f->buildSubPart(t));
6383 ret->setFieldNoProfileSBT(fOut);
6389 std::map<int, MCAuto<DataArrayInt> >::const_iterator it2(extractDef.find(1));
6390 if(it2==extractDef.end())
6391 throw INTERP_KERNEL::Exception("MEDFileField1TS::extractPart : presence of a NODE field and no extract array available for NODE !");
6392 MCAuto<DataArrayInt> t((*it2).second);
6394 throw INTERP_KERNEL::Exception("MEDFileField1TS::extractPart : presence of a value with null pointer 1 !");
6395 MCAuto<MEDCouplingFieldDouble> f(getFieldOnMeshAtLevel(ON_NODES,0,mm));
6396 MCAuto<MEDCouplingFieldDouble> fOut(f->deepCopy());
6397 DataArrayDouble *arr(f->getArray());
6398 MCAuto<DataArrayDouble> newArr(arr->selectByTupleIdSafe(t->begin(),t->end()));
6399 fOut->setArray(newArr);
6400 ret->setFieldNoProfileSBT(fOut);
6406 MEDFileField1TS::MEDFileField1TS(med_idt fid, bool loadAll, const MEDFileMeshes *ms)
6407 try:MEDFileAnyTypeField1TS(fid,loadAll,ms)
6410 catch(INTERP_KERNEL::Exception& e)
6413 MEDFileField1TS::MEDFileField1TS(med_idt fid, const std::string& fieldName, bool loadAll, const MEDFileMeshes *ms)
6414 try:MEDFileAnyTypeField1TS(fid,fieldName,loadAll,ms)
6417 catch(INTERP_KERNEL::Exception& e)
6420 MEDFileField1TS::MEDFileField1TS(med_idt fid, const std::string& fieldName, int iteration, int order, bool loadAll, const MEDFileMeshes *ms)
6421 try:MEDFileAnyTypeField1TS(fid,fieldName,iteration,order,loadAll,ms)
6424 catch(INTERP_KERNEL::Exception& e)
6428 * This constructor is a shallow copy constructor. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
6429 * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
6431 * \warning this is a shallow copy constructor
6433 MEDFileField1TS::MEDFileField1TS(const MEDFileField1TSWithoutSDA& other, bool shallowCopyOfContent)
6434 try:MEDFileAnyTypeField1TS(other,shallowCopyOfContent)
6437 catch(INTERP_KERNEL::Exception& e)
6440 MEDFileField1TS::MEDFileField1TS()
6442 _content=new MEDFileField1TSWithoutSDA;
6446 * This is the simplest version to fetch a field for MED structure. One drawback : if \a this is a complex field (multi spatial discretization inside a same field) this method will throw exception and more advance
6447 * method should be called (getFieldOnMeshAtLevel for example).
6448 * But for normal usage of field in MED file world this method is the most efficient to fetch data.
6450 * \param [in] mesh - the mesh the field is lying on
6451 * \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6452 * caller is to delete this field using decrRef() as it is no more needed.
6454 MEDCouplingFieldDouble *MEDFileField1TS::field(const MEDFileMesh *mesh) const
6456 MCAuto<DataArray> arrOut;
6457 MCAuto<MEDCouplingFieldDouble> ret(contentNotNull()->fieldOnMesh(this,mesh,arrOut,*contentNotNull()));
6458 MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
6463 * Returns a new MEDCouplingFieldDouble of a given type lying on
6464 * mesh entities of a given dimension of the first mesh in MED file. If \a this field
6465 * has not been constructed via file reading, an exception is thrown.
6466 * For more info, see \ref AdvMEDLoaderAPIFieldRW
6467 * \param [in] type - a spatial discretization of interest.
6468 * \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6469 * \param [in] renumPol - specifies how to permute values of the result field according to
6470 * the optional numbers of cells and nodes, if any. The valid values are
6471 * - 0 - do not permute.
6472 * - 1 - permute cells.
6473 * - 2 - permute nodes.
6474 * - 3 - permute cells and nodes.
6476 * \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6477 * caller is to delete this field using decrRef() as it is no more needed.
6478 * \throw If \a this field has not been constructed via file reading.
6479 * \throw If the MED file is not readable.
6480 * \throw If there is no mesh in the MED file.
6481 * \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
6482 * \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6483 * \sa getFieldOnMeshAtLevel()
6485 MEDCouplingFieldDouble *MEDFileField1TS::getFieldAtLevel(TypeOfField type, int meshDimRelToMax, int renumPol) const
6487 if(getFileName().empty())
6488 throw INTERP_KERNEL::Exception("MEDFileField1TS::getFieldAtLevel : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtLevel method instead !");
6489 MCAuto<DataArray> arrOut;
6490 MCAuto<MEDCouplingFieldDouble> ret(contentNotNull()->getFieldAtLevel(type,meshDimRelToMax,std::string(),renumPol,this,arrOut,*contentNotNull()));
6491 MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
6496 * Returns a new MEDCouplingFieldDouble of a given type lying on
6497 * the top level cells of the first mesh in MED file. If \a this field
6498 * has not been constructed via file reading, an exception is thrown.
6499 * For more info, see \ref AdvMEDLoaderAPIFieldRW
6500 * \param [in] type - a spatial discretization of interest.
6501 * \param [in] renumPol - specifies how to permute values of the result field according to
6502 * the optional numbers of cells and nodes, if any. The valid values are
6503 * - 0 - do not permute.
6504 * - 1 - permute cells.
6505 * - 2 - permute nodes.
6506 * - 3 - permute cells and nodes.
6508 * \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6509 * caller is to delete this field using decrRef() as it is no more needed.
6510 * \throw If \a this field has not been constructed via file reading.
6511 * \throw If the MED file is not readable.
6512 * \throw If there is no mesh in the MED file.
6513 * \throw If no field values of the given \a type.
6514 * \throw If no field values lying on the top level support.
6515 * \sa getFieldAtLevel()
6517 MEDCouplingFieldDouble *MEDFileField1TS::getFieldAtTopLevel(TypeOfField type, int renumPol) const
6519 if(getFileName().empty())
6520 throw INTERP_KERNEL::Exception("MEDFileField1TS::getFieldAtTopLevel : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtTopLevel method instead !");
6521 MCAuto<DataArray> arrOut;
6522 MCAuto<MEDCouplingFieldDouble> ret(contentNotNull()->getFieldAtTopLevel(type,std::string(),renumPol,this,arrOut,*contentNotNull()));
6523 MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
6528 * Returns a new MEDCouplingFieldDouble of given type lying on a given mesh.
6529 * For more info, see \ref AdvMEDLoaderAPIFieldRW
6530 * \param [in] type - a spatial discretization of the new field.
6531 * \param [in] mesh - the supporting mesh.
6532 * \param [in] renumPol - specifies how to permute values of the result field according to
6533 * the optional numbers of cells and nodes, if any. The valid values are
6534 * - 0 - do not permute.
6535 * - 1 - permute cells.
6536 * - 2 - permute nodes.
6537 * - 3 - permute cells and nodes.
6539 * \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6540 * caller is to delete this field using decrRef() as it is no more needed.
6541 * \throw If no field of \a this is lying on \a mesh.
6542 * \throw If the mesh is empty.
6543 * \throw If no field values of the given \a type are available.
6544 * \sa getFieldAtLevel()
6545 * \sa getFieldOnMeshAtLevel()
6547 MEDCouplingFieldDouble *MEDFileField1TS::getFieldOnMeshAtLevel(TypeOfField type, const MEDCouplingMesh *mesh, int renumPol) const
6549 MCAuto<DataArray> arrOut;
6550 MCAuto<MEDCouplingFieldDouble> ret(contentNotNull()->getFieldOnMeshAtLevel(type,renumPol,this,mesh,0,0,arrOut,*contentNotNull()));
6551 MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
6556 * Returns a new MEDCouplingFieldDouble of a given type lying on a given support.
6557 * For more info, see \ref AdvMEDLoaderAPIFieldRW
6558 * \param [in] type - a spatial discretization of interest.
6559 * \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6560 * \param [in] mesh - the supporting mesh.
6561 * \param [in] renumPol - specifies how to permute values of the result field according to
6562 * the optional numbers of cells and nodes, if any. The valid values are
6563 * - 0 - do not permute.
6564 * - 1 - permute cells.
6565 * - 2 - permute nodes.
6566 * - 3 - permute cells and nodes.
6568 * \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6569 * caller is to delete this field using decrRef() as it is no more needed.
6570 * \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
6571 * \throw If no field of \a this is lying on \a mesh.
6572 * \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6573 * \sa getFieldAtLevel()
6574 * \sa getFieldOnMeshAtLevel()
6576 MEDCouplingFieldDouble *MEDFileField1TS::getFieldOnMeshAtLevel(TypeOfField type, int meshDimRelToMax, const MEDFileMesh *mesh, int renumPol) const
6578 MCAuto<DataArray> arrOut;
6579 MCAuto<MEDCouplingFieldDouble> ret(contentNotNull()->getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,this,mesh,arrOut,*contentNotNull()));
6580 MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
6585 * Returns a new MEDCouplingFieldDouble of a given type lying on a given support.
6586 * This method is called "Old" because in MED3 norm a field has only one meshName
6587 * attached, so this method is for readers of MED2 files. If \a this field
6588 * has not been constructed via file reading, an exception is thrown.
6589 * For more info, see \ref AdvMEDLoaderAPIFieldRW
6590 * \param [in] type - a spatial discretization of interest.
6591 * \param [in] mName - a name of the supporting mesh.
6592 * \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6593 * \param [in] renumPol - specifies how to permute values of the result field according to
6594 * the optional numbers of cells and nodes, if any. The valid values are
6595 * - 0 - do not permute.
6596 * - 1 - permute cells.
6597 * - 2 - permute nodes.
6598 * - 3 - permute cells and nodes.
6600 * \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6601 * caller is to delete this field using decrRef() as it is no more needed.
6602 * \throw If the MED file is not readable.
6603 * \throw If there is no mesh named \a mName in the MED file.
6604 * \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
6605 * \throw If \a this field has not been constructed via file reading.
6606 * \throw If no field of \a this is lying on the mesh named \a mName.
6607 * \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6608 * \sa getFieldAtLevel()
6610 MEDCouplingFieldDouble *MEDFileField1TS::getFieldAtLevelOld(TypeOfField type, const std::string& mname, int meshDimRelToMax, int renumPol) const
6612 if(getFileName().empty())
6613 throw INTERP_KERNEL::Exception("MEDFileField1TS::getFieldAtLevelOld : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtLevel method instead !");
6614 MCAuto<DataArray> arrOut;
6615 MCAuto<MEDCouplingFieldDouble> ret(contentNotNull()->getFieldAtLevel(type,meshDimRelToMax,mname,renumPol,this,arrOut,*contentNotNull()));
6616 MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
6621 * Returns values and a profile of the field of a given type lying on a given support.
6622 * For more info, see \ref AdvMEDLoaderAPIFieldRW
6623 * \param [in] type - a spatial discretization of the field.
6624 * \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6625 * \param [in] mesh - the supporting mesh.
6626 * \param [out] pfl - a new instance of DataArrayInt holding ids of mesh entities the
6627 * field of interest lies on. If the field lies on all entities of the given
6628 * dimension, all ids in \a pfl are zero. The caller is to delete this array
6629 * using decrRef() as it is no more needed.
6630 * \return DataArrayDouble * - a new instance of DataArrayDouble holding values of the
6631 * field. The caller is to delete this array using decrRef() as it is no more needed.
6632 * \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
6633 * \throw If no field of \a this is lying on \a mesh.
6634 * \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6636 DataArrayDouble *MEDFileField1TS::getFieldWithProfile(TypeOfField type, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt *&pfl) const
6638 MCAuto<DataArray> ret=contentNotNull()->getFieldWithProfile(type,meshDimRelToMax,mesh,pfl,this,*contentNotNull());
6639 return MEDFileField1TS::ReturnSafelyDataArrayDouble(ret);
6643 * Adds a MEDCouplingFieldDouble to \a this. The underlying mesh of the given field is
6644 * checked if its elements are sorted suitable for writing to MED file ("STB" stands for
6645 * "Sort By Type"), if not, an exception is thrown.
6646 * For more info, see \ref AdvMEDLoaderAPIFieldRW
6647 * \param [in] field - the field to add to \a this.
6648 * \throw If the name of \a field is empty.
6649 * \throw If the data array of \a field is not set.
6650 * \throw If the data array is already allocated but has different number of components
6652 * \throw If the underlying mesh of \a field has no name.
6653 * \throw If elements in the mesh are not in the order suitable for writing to the MED file.
6655 void MEDFileField1TS::setFieldNoProfileSBT(const MEDCouplingFieldDouble *field)
6658 contentNotNull()->setFieldNoProfileSBT(field,field->getArray(),*this,*contentNotNull());
6662 * Adds a MEDCouplingFieldDouble to \a this. As described in \ref MEDLoaderMainC a field in MED file sense
6663 * can be an aggregation of several MEDCouplingFieldDouble instances.
6664 * The mesh support of input parameter \a field is ignored here, it can be NULL.
6665 * The support of field \a field is expected to be those computed with the input parameter \a mesh, \a meshDimRelToMax,
6668 * This method will check that the field based on the computed support is coherent. If not an exception will be thrown.
6669 * A new profile is added only if no equal profile is missing.
6670 * For more info, see \ref AdvMEDLoaderAPIFieldRW
6671 * \param [in] field - the field to add to \a this. The mesh support of field is ignored.
6672 * \param [in] mesh - the supporting mesh of \a field.
6673 * \param [in] meshDimRelToMax - a relative dimension of mesh entities \a field lies on (useless if field spatial discretization is ON_NODES).
6674 * \param [in] profile - ids of mesh entities on which corresponding field values lie.
6675 * \throw If either \a field or \a mesh or \a profile has an empty name.
6676 * \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
6677 * \throw If the data array of \a field is not set.
6678 * \throw If the data array of \a this is already allocated but has different number of
6679 * components than \a field.
6680 * \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
6681 * \sa setFieldNoProfileSBT()
6683 void MEDFileField1TS::setFieldProfile(const MEDCouplingFieldDouble *field, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile)
6686 contentNotNull()->setFieldProfile(field,field->getArray(),mesh,meshDimRelToMax,profile,*this,*contentNotNull());
6689 MEDFileAnyTypeField1TS *MEDFileField1TS::shallowCpy() const
6691 return new MEDFileField1TS(*this);
6694 DataArrayDouble *MEDFileField1TS::getUndergroundDataArray() const
6696 return contentNotNull()->getUndergroundDataArrayTemplate();
6699 DataArrayDouble *MEDFileField1TS::getUndergroundDataArrayExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
6701 return contentNotNull()->getUndergroundDataArrayDoubleExt(entries);
6704 std::vector< std::vector<DataArrayDouble *> > MEDFileField1TS::getFieldSplitedByType2(const std::string& mname, std::vector<INTERP_KERNEL::NormalizedCellType>& types, std::vector< std::vector<TypeOfField> >& typesF,
6705 std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> >& locs) const
6707 return contentNotNull()->getFieldSplitedByType2(mname,types,typesF,pfls,locs);
6710 //= MEDFileIntField1TS
6712 MEDFileIntField1TS *MEDFileIntField1TS::New()
6714 MCAuto<MEDFileIntField1TS> ret(new MEDFileIntField1TS);
6715 ret->contentNotNull();
6719 MEDFileIntField1TS *MEDFileIntField1TS::New(const std::string& fileName, bool loadAll)
6721 MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
6722 MCAuto<MEDFileIntField1TS> ret(new MEDFileIntField1TS(fid,loadAll,0));
6723 ret->contentNotNull();
6727 MEDFileIntField1TS *MEDFileIntField1TS::New(const std::string& fileName, const std::string& fieldName, bool loadAll)
6729 MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
6730 MCAuto<MEDFileIntField1TS> ret(new MEDFileIntField1TS(fid,fieldName,loadAll,0));
6731 ret->contentNotNull();
6735 MEDFileIntField1TS *MEDFileIntField1TS::New(const std::string& fileName, const std::string& fieldName, int iteration, int order, bool loadAll)
6737 MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
6738 MCAuto<MEDFileIntField1TS> ret(new MEDFileIntField1TS(fid,fieldName,iteration,order,loadAll,0));
6739 ret->contentNotNull();
6743 MEDFileIntField1TS *MEDFileIntField1TS::New(const MEDFileIntField1TSWithoutSDA& other, bool shallowCopyOfContent)
6745 MCAuto<MEDFileIntField1TS> ret=new MEDFileIntField1TS(other,shallowCopyOfContent);
6746 ret->contentNotNull();
6750 MEDFileIntField1TS::MEDFileIntField1TS()
6752 _content=new MEDFileIntField1TSWithoutSDA;
6755 MEDFileIntField1TS::MEDFileIntField1TS(med_idt fid, bool loadAll, const MEDFileMeshes *ms)
6756 try:MEDFileAnyTypeField1TS(fid,loadAll,ms)
6759 catch(INTERP_KERNEL::Exception& e)
6762 MEDFileIntField1TS::MEDFileIntField1TS(med_idt fid, const std::string& fieldName, bool loadAll, const MEDFileMeshes *ms)
6763 try:MEDFileAnyTypeField1TS(fid,fieldName,loadAll,ms)
6766 catch(INTERP_KERNEL::Exception& e)
6769 MEDFileIntField1TS::MEDFileIntField1TS(med_idt fid, const std::string& fieldName, int iteration, int order, bool loadAll, const MEDFileMeshes *ms)
6770 try:MEDFileAnyTypeField1TS(fid,fieldName,iteration,order,loadAll,ms)
6773 catch(INTERP_KERNEL::Exception& e)
6777 * This constructor is a shallow copy constructor. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
6778 * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
6780 * \warning this is a shallow copy constructor
6782 MEDFileIntField1TS::MEDFileIntField1TS(const MEDFileIntField1TSWithoutSDA& other, bool shallowCopyOfContent):MEDFileAnyTypeField1TS(other,shallowCopyOfContent)
6786 MEDFileAnyTypeField1TS *MEDFileIntField1TS::shallowCpy() const
6788 return new MEDFileIntField1TS(*this);
6792 * This method performs a copy with datatype modification ( int32->float64 ) of \a this. The globals information are copied
6793 * following the given input policy.
6795 * \param [in] isDeepCpyGlobs - a boolean that indicates the behaviour concerning globals (profiles and localizations)
6796 * By default (true) the globals are deeply copied.
6797 * \return MEDFileField1TS * - a new object that is the result of the conversion of \a this to float64 field.
6799 MEDFileField1TS *MEDFileIntField1TS::convertToDouble(bool isDeepCpyGlobs) const
6801 MCAuto<MEDFileField1TS> ret;
6802 const MEDFileAnyTypeField1TSWithoutSDA *content(_content);
6805 const MEDFileIntField1TSWithoutSDA *contc=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(content);
6807 throw INTERP_KERNEL::Exception("MEDFileIntField1TS::convertToInt : the content inside this is not INT32 ! This is incoherent !");
6808 MCAuto<MEDFileField1TSWithoutSDA> newc(contc->convertToDouble());
6809 ret=static_cast<MEDFileField1TS *>(MEDFileAnyTypeField1TS::BuildNewInstanceFromContent((MEDFileField1TSWithoutSDA *)newc));
6812 ret=MEDFileField1TS::New();
6814 ret->deepCpyGlobs(*this);
6816 ret->shallowCpyGlobs(*this);
6821 * Adds a MEDCouplingFieldInt to \a this. The underlying mesh of the given field is
6822 * checked if its elements are sorted suitable for writing to MED file ("STB" stands for
6823 * "Sort By Type"), if not, an exception is thrown.
6824 * For more info, see \ref AdvMEDLoaderAPIFieldRW
6825 * \param [in] field - the field to add to \a this.
6826 * \throw If the name of \a field is empty.
6827 * \throw If the data array of \a field is not set.
6828 * \throw If the data array is already allocated but has different number of components
6830 * \throw If the underlying mesh of \a field has no name.
6831 * \throw If elements in the mesh are not in the order suitable for writing to the MED file.
6833 void MEDFileIntField1TS::setFieldNoProfileSBT(const MEDCouplingFieldInt *field)
6835 MCAuto<MEDCouplingFieldDouble> field2(ConvertFieldIntToFieldDouble(field));
6837 contentNotNull()->setFieldNoProfileSBT(field2,field->getArray(),*this,*contentNotNull());
6841 * Adds a MEDCouplingFieldInt to \a this. As described in \ref MEDLoaderMainC a field in MED file sense
6842 * can be an aggregation of several MEDCouplingFieldDouble instances.
6843 * The mesh support of input parameter \a field is ignored here, it can be NULL.
6844 * The support of field \a field is expected to be those computed with the input parameter \a mesh, \a meshDimRelToMax,
6847 * This method will check that the field based on the computed support is coherent. If not an exception will be thrown.
6848 * A new profile is added only if no equal profile is missing.
6849 * For more info, see \ref AdvMEDLoaderAPIFieldRW
6850 * \param [in] field - the field to add to \a this.
6851 * \param [in] mesh - the supporting mesh of \a field.
6852 * \param [in] meshDimRelToMax - a relative dimension of mesh entities \a field lies on (useless if field spatial discretization is ON_NODES).
6853 * \param [in] profile - ids of mesh entities on which corresponding field values lie.
6854 * \throw If either \a field or \a mesh or \a profile has an empty name.
6855 * \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
6856 * \throw If the data array of \a field is not set.
6857 * \throw If the data array of \a this is already allocated but has different number of
6858 * components than \a field.
6859 * \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
6860 * \sa setFieldNoProfileSBT()
6862 void MEDFileIntField1TS::setFieldProfile(const MEDCouplingFieldInt *field, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile)
6864 MCAuto<MEDCouplingFieldDouble> field2(ConvertFieldIntToFieldDouble(field));
6866 contentNotNull()->setFieldProfile(field2,field->getArray(),mesh,meshDimRelToMax,profile,*this,*contentNotNull());
6869 const MEDFileIntField1TSWithoutSDA *MEDFileIntField1TS::contentNotNull() const
6871 const MEDFileAnyTypeField1TSWithoutSDA *pt(_content);
6873 throw INTERP_KERNEL::Exception("MEDFileIntField1TS::contentNotNull : the content pointer is null !");
6874 const MEDFileIntField1TSWithoutSDA *ret=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(pt);
6876 throw INTERP_KERNEL::Exception("MEDFileIntField1TS::contentNotNull : the content pointer is not null but it is not of type int32 ! Reason is maybe that the read field has not the type INT32 !");
6880 MEDCouplingFieldInt *MEDFileIntField1TS::getFieldAtLevel(TypeOfField type, int meshDimRelToMax, int renumPol) const
6882 if(getFileName().empty())
6883 throw INTERP_KERNEL::Exception("MEDFileIntField1TS::getFieldAtLevel : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtLevel method instead !");
6884 MCAuto<DataArray> arrOut;
6885 MCAuto<MEDCouplingFieldDouble> ret(contentNotNull()->getFieldAtLevel(type,meshDimRelToMax,std::string(),renumPol,this,arrOut,*contentNotNull()));
6886 MCAuto<MEDCouplingFieldInt> ret2(SetDataArrayDoubleInIntField(ret,arrOut));
6890 DataArrayInt *MEDFileIntField1TS::ReturnSafelyDataArrayInt(MCAuto<DataArray>& arr)
6893 throw INTERP_KERNEL::Exception("MEDFileIntField1TS::ReturnSafelyDataArrayInt : input DataArray is NULL !");
6894 DataArrayInt *arrC(dynamic_cast<DataArrayInt *>((DataArray *)arr));
6896 throw INTERP_KERNEL::Exception("MEDFileIntField1TS::ReturnSafelyDataArrayInt : input DataArray is not of type INT32 !");
6901 MCAuto<MEDCouplingFieldInt> MEDFileIntField1TS::SetDataArrayDoubleInIntField(MEDCouplingFieldDouble *f, MCAuto<DataArray>& arr)
6904 double t0(f->getTime(t1,t2));
6905 MCAuto<DataArrayInt> arr2(DynamicCastSafe<DataArray,DataArrayInt>(arr));
6906 MCAuto<MEDCouplingFieldTemplate> ft(MEDCouplingFieldTemplate::New(*f));
6907 MCAuto<MEDCouplingFieldInt> ret(MEDCouplingFieldInt::New(*ft));
6908 ret->setTime(t0,t1,t2); ret->setArray(arr2);
6912 MCAuto<MEDCouplingFieldDouble> MEDFileIntField1TS::ConvertFieldIntToFieldDouble(const MEDCouplingFieldInt *f)
6915 throw INTERP_KERNEL::Exception("MEDFileIntField1TS::ConvertFieldIntToFieldDouble : null input field !");
6917 double t0(f->getTime(t1,t2));
6918 MCAuto<MEDCouplingFieldTemplate> ft(MEDCouplingFieldTemplate::New(*f));
6919 MCAuto<MEDCouplingFieldDouble> ret(MEDCouplingFieldDouble::New(*ft));
6920 ret->setTime(t0,t1,t2);
6924 MEDFileIntField1TS *MEDFileIntField1TS::extractPart(const std::map<int, MCAuto<DataArrayInt> >& extractDef, MEDFileMesh *mm) const
6926 throw INTERP_KERNEL::Exception("MEDFileIntField1TS::extractPart : not implemented yet !");
6930 * This is the simplest version to fetch a field for MED structure. One drawback : if \a this is a complex field (multi spatial discretization inside a same field) this method will throw exception and more advance
6931 * method should be called (getFieldOnMeshAtLevel for example).
6932 * But for normal usage of field in MED file world this method is the most efficient to fetch data.
6934 * \param [in] mesh - the mesh the field is lying on
6935 * \return MEDCouplingFieldInt * - a new instance of MEDCouplingFieldInt. The
6936 * caller is to delete this field using decrRef() as it is no more needed.
6938 MEDCouplingFieldInt *MEDFileIntField1TS::field(const MEDFileMesh *mesh) const
6940 MCAuto<DataArray> arrOut;
6941 MCAuto<MEDCouplingFieldDouble> ret(contentNotNull()->fieldOnMesh(this,mesh,arrOut,*contentNotNull()));
6942 MCAuto<MEDCouplingFieldInt> ret2(SetDataArrayDoubleInIntField(ret,arrOut));
6947 * Returns a new MEDCouplingFieldInt of a given type lying on
6948 * the top level cells of the first mesh in MED file. If \a this field
6949 * has not been constructed via file reading, an exception is thrown.
6950 * For more info, see \ref AdvMEDLoaderAPIFieldRW
6951 * \param [in] type - a spatial discretization of interest.
6952 * \param [in] renumPol - specifies how to permute values of the result field according to
6953 * the optional numbers of cells and nodes, if any. The valid values are
6954 * - 0 - do not permute.
6955 * - 1 - permute cells.
6956 * - 2 - permute nodes.
6957 * - 3 - permute cells and nodes.
6959 * \return MEDCouplingFieldInt * - a new instance of MEDCouplingFieldDouble. The
6960 * caller is to delete this field using decrRef() as it is no more needed.
6961 * \throw If \a this field has not been constructed via file reading.
6962 * \throw If the MED file is not readable.
6963 * \throw If there is no mesh in the MED file.
6964 * \throw If no field values of the given \a type.
6965 * \throw If no field values lying on the top level support.
6966 * \sa getFieldAtLevel()
6968 MEDCouplingFieldInt *MEDFileIntField1TS::getFieldAtTopLevel(TypeOfField type, int renumPol) const
6970 if(getFileName().empty())
6971 throw INTERP_KERNEL::Exception("MEDFileField1TS::getFieldAtTopLevel : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtTopLevel method instead !");
6972 MCAuto<DataArray> arrOut;
6973 MCAuto<MEDCouplingFieldDouble> ret(contentNotNull()->getFieldAtTopLevel(type,std::string(),renumPol,this,arrOut,*contentNotNull()));
6974 MCAuto<MEDCouplingFieldInt> ret2(SetDataArrayDoubleInIntField(ret,arrOut));
6979 * Returns a new MEDCouplingFieldInt of given type lying on a given mesh.
6980 * For more info, see \ref AdvMEDLoaderAPIFieldRW
6981 * \param [in] type - a spatial discretization of the new field.
6982 * \param [in] mesh - the supporting mesh.
6983 * \param [in] renumPol - specifies how to permute values of the result field according to
6984 * the optional numbers of cells and nodes, if any. The valid values are
6985 * - 0 - do not permute.
6986 * - 1 - permute cells.
6987 * - 2 - permute nodes.
6988 * - 3 - permute cells and nodes.
6990 * \return MEDCouplingFieldInt * - a new instance of MEDCouplingFieldDouble. The
6991 * caller is to delete this field using decrRef() as it is no more needed.
6992 * \throw If no field of \a this is lying on \a mesh.
6993 * \throw If the mesh is empty.
6994 * \throw If no field values of the given \a type are available.
6995 * \sa getFieldAtLevel()
6996 * \sa getFieldOnMeshAtLevel()
6998 MEDCouplingFieldInt *MEDFileIntField1TS::getFieldOnMeshAtLevel(TypeOfField type, const MEDCouplingMesh *mesh, int renumPol) const
7000 MCAuto<DataArray> arrOut;
7001 MCAuto<MEDCouplingFieldDouble> ret(contentNotNull()->getFieldOnMeshAtLevel(type,renumPol,this,mesh,0,0,arrOut,*contentNotNull()));
7002 MCAuto<MEDCouplingFieldInt> ret2(SetDataArrayDoubleInIntField(ret,arrOut));
7007 * Returns a new MEDCouplingFieldInt of a given type lying on a given support.
7008 * For more info, see \ref AdvMEDLoaderAPIFieldRW
7009 * \param [in] type - a spatial discretization of interest.
7010 * \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
7011 * \param [in] mesh - the supporting mesh.
7012 * \param [in] renumPol - specifies how to permute values of the result field according to
7013 * the optional numbers of cells and nodes, if any. The valid values are
7014 * - 0 - do not permute.
7015 * - 1 - permute cells.
7016 * - 2 - permute nodes.
7017 * - 3 - permute cells and nodes.
7019 * \return MEDCouplingFieldInt * - a new instance of MEDCouplingFieldDouble. The
7020 * caller is to delete this field using decrRef() as it is no more needed.
7021 * \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
7022 * \throw If no field of \a this is lying on \a mesh.
7023 * \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
7024 * \sa getFieldAtLevel()
7025 * \sa getFieldOnMeshAtLevel()
7027 MEDCouplingFieldInt *MEDFileIntField1TS::getFieldOnMeshAtLevel(TypeOfField type, int meshDimRelToMax, const MEDFileMesh *mesh, int renumPol) const
7029 MCAuto<DataArray> arrOut;
7030 MCAuto<MEDCouplingFieldDouble> ret(contentNotNull()->getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,this,mesh,arrOut,*contentNotNull()));
7031 MCAuto<MEDCouplingFieldInt> ret2(SetDataArrayDoubleInIntField(ret,arrOut));
7036 * Returns a new MEDCouplingFieldDouble of a given type lying on a given support.
7037 * This method is called "Old" because in MED3 norm a field has only one meshName
7038 * attached, so this method is for readers of MED2 files. If \a this field
7039 * has not been constructed via file reading, an exception is thrown.
7040 * For more info, see \ref AdvMEDLoaderAPIFieldRW
7041 * \param [in] type - a spatial discretization of interest.
7042 * \param [in] mName - a name of the supporting mesh.
7043 * \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
7044 * \param [in] renumPol - specifies how to permute values of the result field according to
7045 * the optional numbers of cells and nodes, if any. The valid values are
7046 * - 0 - do not permute.
7047 * - 1 - permute cells.
7048 * - 2 - permute nodes.
7049 * - 3 - permute cells and nodes.
7051 * \return MEDCouplingFieldInt * - a new instance of MEDCouplingFieldDouble. The
7052 * caller is to delete this field using decrRef() as it is no more needed.
7053 * \throw If the MED file is not readable.
7054 * \throw If there is no mesh named \a mName in the MED file.
7055 * \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
7056 * \throw If \a this field has not been constructed via file reading.
7057 * \throw If no field of \a this is lying on the mesh named \a mName.
7058 * \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
7059 * \sa getFieldAtLevel()
7061 MEDCouplingFieldInt *MEDFileIntField1TS::getFieldAtLevelOld(TypeOfField type, const std::string& mname, int meshDimRelToMax, int renumPol) const
7063 if(getFileName().empty())
7064 throw INTERP_KERNEL::Exception("MEDFileIntField1TS::getFieldAtLevelOld : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtLevel method instead !");
7065 MCAuto<DataArray> arrOut;
7066 MCAuto<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldAtLevel(type,meshDimRelToMax,mname,renumPol,this,arrOut,*contentNotNull());
7067 MCAuto<MEDCouplingFieldInt> ret2(SetDataArrayDoubleInIntField(ret,arrOut));
7072 * Returns values and a profile of the field of a given type lying on a given support.
7073 * For more info, see \ref AdvMEDLoaderAPIFieldRW
7074 * \param [in] type - a spatial discretization of the field.
7075 * \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
7076 * \param [in] mesh - the supporting mesh.
7077 * \param [out] pfl - a new instance of DataArrayInt holding ids of mesh entities the
7078 * field of interest lies on. If the field lies on all entities of the given
7079 * dimension, all ids in \a pfl are zero. The caller is to delete this array
7080 * using decrRef() as it is no more needed.
7081 * \return DataArrayInt * - a new instance of DataArrayInt holding values of the
7082 * field. The caller is to delete this array using decrRef() as it is no more needed.
7083 * \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
7084 * \throw If no field of \a this is lying on \a mesh.
7085 * \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
7087 DataArrayInt *MEDFileIntField1TS::getFieldWithProfile(TypeOfField type, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt *&pfl) const
7089 MCAuto<DataArray> arr=contentNotNull()->getFieldWithProfile(type,meshDimRelToMax,mesh,pfl,this,*contentNotNull());
7090 return MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
7093 MEDFileIntField1TSWithoutSDA *MEDFileIntField1TS::contentNotNull()
7095 MEDFileAnyTypeField1TSWithoutSDA *pt(_content);
7097 throw INTERP_KERNEL::Exception("MEDFileIntField1TS::contentNotNull : the non const content pointer is null !");
7098 MEDFileIntField1TSWithoutSDA *ret=dynamic_cast<MEDFileIntField1TSWithoutSDA *>(pt);
7100 throw INTERP_KERNEL::Exception("MEDFileIntField1TS::contentNotNull : the non const content pointer is not null but it is not of type int32 ! Reason is maybe that the read field has not the type INT32 !");
7104 DataArrayInt *MEDFileIntField1TS::getUndergroundDataArray() const
7106 return contentNotNull()->getUndergroundDataArrayTemplate();
7109 //= MEDFileAnyTypeFieldMultiTSWithoutSDA
7111 MEDFileAnyTypeFieldMultiTSWithoutSDA::MEDFileAnyTypeFieldMultiTSWithoutSDA()
7115 MEDFileAnyTypeFieldMultiTSWithoutSDA::MEDFileAnyTypeFieldMultiTSWithoutSDA(const std::string& fieldName):MEDFileFieldNameScope(fieldName)
7120 * \param [in] fieldId field id in C mode
7122 MEDFileAnyTypeFieldMultiTSWithoutSDA::MEDFileAnyTypeFieldMultiTSWithoutSDA(med_idt fid, int fieldId, bool loadAll, const MEDFileMeshes *ms, const std::vector< std::pair<TypeOfField,INTERP_KERNEL::NormalizedCellType> > *entities)
7124 med_field_type typcha;
7125 std::string dtunitOut;
7126 int nbOfStep(MEDFileAnyTypeField1TS::LocateField2(fid,fieldId,false,_name,typcha,_infos,dtunitOut));
7127 setDtUnit(dtunitOut.c_str());
7128 loadStructureOrStructureAndBigArraysRecursively(fid,nbOfStep,typcha,loadAll,ms,entities);
7131 MEDFileAnyTypeFieldMultiTSWithoutSDA::MEDFileAnyTypeFieldMultiTSWithoutSDA(med_idt fid, const std::string& fieldName, med_field_type fieldTyp, const std::vector<std::string>& infos, int nbOfStep, const std::string& dtunit, bool loadAll, const MEDFileMeshes *ms, const std::vector< std::pair<TypeOfField,INTERP_KERNEL::NormalizedCellType> > *entities)
7132 try:MEDFileFieldNameScope(fieldName),_infos(infos)
7134 setDtUnit(dtunit.c_str());
7135 loadStructureOrStructureAndBigArraysRecursively(fid,nbOfStep,fieldTyp,loadAll,ms,entities);
7137 catch(INTERP_KERNEL::Exception& e)
7142 std::size_t MEDFileAnyTypeFieldMultiTSWithoutSDA::getHeapMemorySizeWithoutChildren() const
7144 std::size_t ret(_name.capacity()+_infos.capacity()*sizeof(std::string)+_time_steps.capacity()*sizeof(MCAuto<MEDFileField1TSWithoutSDA>));
7145 for(std::vector<std::string>::const_iterator it=_infos.begin();it!=_infos.end();it++)
7146 ret+=(*it).capacity();
7150 std::vector<const BigMemoryObject *> MEDFileAnyTypeFieldMultiTSWithoutSDA::getDirectChildrenWithNull() const
7152 std::vector<const BigMemoryObject *> ret;
7153 for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7154 ret.push_back((const MEDFileAnyTypeField1TSWithoutSDA *)*it);
7159 * If one of the id in [ \a startIds , \a endIds ) points to a null element, there is not throw. Simply, this empty element is added as if it were not
7162 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::buildFromTimeStepIds(const int *startIds, const int *endIds) const
7164 MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> ret=createNew();
7165 ret->setInfo(_infos);
7166 int sz=(int)_time_steps.size();
7167 for(const int *id=startIds;id!=endIds;id++)
7169 if(*id>=0 && *id<sz)
7171 const MEDFileAnyTypeField1TSWithoutSDA *tse=_time_steps[*id];
7172 MCAuto<MEDFileAnyTypeField1TSWithoutSDA> tse2;
7176 tse2=(const_cast<MEDFileAnyTypeField1TSWithoutSDA *>(tse));
7178 ret->pushBackTimeStep(tse2);
7182 std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::buildFromTimeStepIds : At pos #" << std::distance(startIds,id) << " value is " << *id;
7183 oss << " ! Should be in [0," << sz << ") !";
7184 throw INTERP_KERNEL::Exception(oss.str());
7187 if(ret->getNumberOfTS()>0)
7188 ret->synchronizeNameScope();
7189 ret->copyNameScope(*this);
7194 * If one of the id in the input range points to a null element, there is not throw. Simply, this empty element is added as if it were not
7197 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::buildFromTimeStepIds2(int bg, int end, int step) const
7199 static const char msg[]="MEDFileAnyTypeFieldMultiTSWithoutSDA::buildFromTimeStepIds2";
7200 int nbOfEntriesToKeep=DataArrayInt::GetNumberOfItemGivenBESRelative(bg,end,step,msg);
7201 MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> ret=createNew();
7202 ret->setInfo(_infos);
7203 int sz=(int)_time_steps.size();
7205 for(int i=0;i<nbOfEntriesToKeep;i++,j+=step)
7209 const MEDFileAnyTypeField1TSWithoutSDA *tse=_time_steps[j];
7210 MCAuto<MEDFileAnyTypeField1TSWithoutSDA> tse2;
7214 tse2=(const_cast<MEDFileAnyTypeField1TSWithoutSDA *>(tse));
7216 ret->pushBackTimeStep(tse2);
7220 std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::buildFromTimeStepIds : At pos #" << i << " value is " << j;
7221 oss << " ! Should be in [0," << sz << ") !";
7222 throw INTERP_KERNEL::Exception(oss.str());
7225 if(ret->getNumberOfTS()>0)
7226 ret->synchronizeNameScope();
7227 ret->copyNameScope(*this);
7231 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::partOfThisLyingOnSpecifiedTimeSteps(const std::vector< std::pair<int,int> >& timeSteps) const
7234 MCAuto<DataArrayInt> ids=DataArrayInt::New(); ids->alloc(0,1);
7235 for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,id++)
7237 const MEDFileAnyTypeField1TSWithoutSDA *cur(*it);
7240 std::pair<int,int> p(cur->getIteration(),cur->getOrder());
7241 if(std::find(timeSteps.begin(),timeSteps.end(),p)!=timeSteps.end())
7242 ids->pushBackSilent(id);
7244 return buildFromTimeStepIds(ids->begin(),ids->end());
7247 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::partOfThisNotLyingOnSpecifiedTimeSteps(const std::vector< std::pair<int,int> >& timeSteps) const
7250 MCAuto<DataArrayInt> ids=DataArrayInt::New(); ids->alloc(0,1);
7251 for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,id++)
7253 const MEDFileAnyTypeField1TSWithoutSDA *cur(*it);
7256 std::pair<int,int> p(cur->getIteration(),cur->getOrder());
7257 if(std::find(timeSteps.begin(),timeSteps.end(),p)==timeSteps.end())
7258 ids->pushBackSilent(id);
7260 return buildFromTimeStepIds(ids->begin(),ids->end());
7263 bool MEDFileAnyTypeFieldMultiTSWithoutSDA::presenceOfMultiDiscPerGeoType() const
7265 for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7267 const MEDFileAnyTypeField1TSWithoutSDA *cur(*it);
7270 if(cur->presenceOfMultiDiscPerGeoType())
7276 const std::vector<std::string>& MEDFileAnyTypeFieldMultiTSWithoutSDA::getInfo() const
7281 void MEDFileAnyTypeFieldMultiTSWithoutSDA::setInfo(const std::vector<std::string>& info)
7286 int MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepPos(int iteration, int order) const
7289 for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,ret++)
7291 const MEDFileAnyTypeField1TSWithoutSDA *pt(*it);
7292 if(pt->isDealingTS(iteration,order))
7295 std::ostringstream oss; oss << "MEDFileFieldMultiTS::getTimeStepPos : Muli timestep field on time (" << iteration << "," << order << ") does not exist ! Available (iteration,order) are :\n";
7296 std::vector< std::pair<int,int> > vp=getIterations();
7297 for(std::vector< std::pair<int,int> >::const_iterator it2=vp.begin();it2!=vp.end();it2++)
7298 oss << "(" << (*it2).first << "," << (*it2).second << ") ";
7299 throw INTERP_KERNEL::Exception(oss.str());
7302 const MEDFileAnyTypeField1TSWithoutSDA& MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepEntry(int iteration, int order) const
7304 return *_time_steps[getTimeStepPos(iteration,order)];
7307 MEDFileAnyTypeField1TSWithoutSDA& MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepEntry(int iteration, int order)
7309 return *_time_steps[getTimeStepPos(iteration,order)];
7312 std::string MEDFileAnyTypeFieldMultiTSWithoutSDA::getMeshName() const
7314 if(_time_steps.empty())
7315 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::getMeshName : not time steps !");
7316 return _time_steps[0]->getMeshName();
7319 void MEDFileAnyTypeFieldMultiTSWithoutSDA::setMeshName(const std::string& newMeshName)
7321 std::string oldName(getMeshName());
7322 std::vector< std::pair<std::string,std::string> > v(1);
7323 v[0].first=oldName; v[0].second=newMeshName;
7327 bool MEDFileAnyTypeFieldMultiTSWithoutSDA::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab)
7330 for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7332 MEDFileAnyTypeField1TSWithoutSDA *cur(*it);
7334 ret=cur->changeMeshNames(modifTab) || ret;
7340 * See doc at MEDFileField1TSWithoutSDA::getUndergroundDataArray
7342 DataArray *MEDFileAnyTypeFieldMultiTSWithoutSDA::getUndergroundDataArray(int iteration, int order) const
7344 return getTimeStepEntry(iteration,order).getUndergroundDataArray();
7348 * See doc at MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt
7350 DataArray *MEDFileAnyTypeFieldMultiTSWithoutSDA::getUndergroundDataArrayExt(int iteration, int order, std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
7352 return getTimeStepEntry(iteration,order).getUndergroundDataArrayExt(entries);
7355 bool MEDFileAnyTypeFieldMultiTSWithoutSDA::renumberEntitiesLyingOnMesh(const std::string& meshName, const std::vector<int>& oldCode, const std::vector<int>& newCode, const DataArrayInt *renumO2N,
7356 MEDFileFieldGlobsReal& glob)
7359 for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7361 MEDFileAnyTypeField1TSWithoutSDA *f1ts(*it);
7363 ret=f1ts->renumberEntitiesLyingOnMesh(meshName,oldCode,newCode,renumO2N,glob) || ret;
7368 void MEDFileAnyTypeFieldMultiTSWithoutSDA::simpleRepr(int bkOffset, std::ostream& oss, int fmtsId) const
7370 std::string startLine(bkOffset,' ');
7371 oss << startLine << "Field multi time steps [Type=" << getTypeStr() << "]";
7373 oss << " (" << fmtsId << ")";
7374 oss << " has the following name: \"" << _name << "\"." << std::endl;
7375 oss << startLine << "Field multi time steps has " << _infos.size() << " components with the following infos :" << std::endl;
7376 for(std::vector<std::string>::const_iterator it=_infos.begin();it!=_infos.end();it++)
7378 oss << startLine << " - \"" << *it << "\"" << std::endl;
7381 for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,i++)
7383 std::string chapter(17,'0'+i);
7384 oss << startLine << chapter << std::endl;
7385 const MEDFileAnyTypeField1TSWithoutSDA *cur=(*it);
7387 cur->simpleRepr(bkOffset+2,oss,i);
7389 oss << startLine << " Field on one time step #" << i << " is not defined !" << std::endl;
7390 oss << startLine << chapter << std::endl;
7394 std::vector< std::pair<int,int> > MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeSteps(std::vector<double>& ret1) const
7396 std::size_t sz=_time_steps.size();
7397 std::vector< std::pair<int,int> > ret(sz);
7399 for(std::size_t i=0;i<sz;i++)
7401 const MEDFileAnyTypeField1TSWithoutSDA *f1ts=_time_steps[i];
7404 ret1[i]=f1ts->getTime(ret[i].first,ret[i].second);
7408 std::ostringstream oss; oss << "MEDFileFieldMultiTSWithoutSDA::getTimeSteps : At rank #" << i << " time step is not defined. Invoke eraseEmptyTS method !";
7409 throw INTERP_KERNEL::Exception(oss.str());
7415 void MEDFileAnyTypeFieldMultiTSWithoutSDA::pushBackTimeStep(MCAuto<MEDFileAnyTypeField1TSWithoutSDA>& tse)
7417 MEDFileAnyTypeField1TSWithoutSDA *tse2(tse);
7419 throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::pushBackTimeStep : input content object is null !");
7420 checkCoherencyOfType(tse2);
7421 if(_time_steps.empty())
7423 setName(tse2->getName().c_str());
7424 setInfo(tse2->getInfo());
7426 checkThatComponentsMatch(tse2->getInfo());
7427 if(getDtUnit().empty() && !tse->getDtUnit().empty())
7428 setDtUnit(tse->getDtUnit());
7429 _time_steps.push_back(tse);
7432 void MEDFileAnyTypeFieldMultiTSWithoutSDA::synchronizeNameScope()
7434 std::size_t nbOfCompo=_infos.size();
7435 for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7437 MEDFileAnyTypeField1TSWithoutSDA *cur=(*it);
7440 if((cur->getInfo()).size()!=nbOfCompo)
7442 std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::synchronizeNameScope : Mismatch in the number of components of parts ! Should be " << nbOfCompo;
7443 oss << " ! but the field at iteration=" << cur->getIteration() << " order=" << cur->getOrder() << " has " << (cur->getInfo()).size() << " components !";
7444 throw INTERP_KERNEL::Exception(oss.str());
7446 cur->copyNameScope(*this);
7451 void MEDFileAnyTypeFieldMultiTSWithoutSDA::loadStructureOrStructureAndBigArraysRecursively(med_idt fid, int nbPdt, med_field_type fieldTyp, bool loadAll, const MEDFileMeshes *ms, const std::vector< std::pair<TypeOfField,INTERP_KERNEL::NormalizedCellType> > *entities)
7453 _time_steps.resize(nbPdt);
7454 for(int i=0;i<nbPdt;i++)
7456 std::vector< std::pair<int,int> > ts;
7457 med_int numdt=0,numo=0;
7458 med_int meshIt=0,meshOrder=0;
7460 MEDFILESAFECALLERRD0(MEDfieldComputingStepMeshInfo,(fid,_name.c_str(),i+1,&numdt,&numo,&dt,&meshIt,&meshOrder));
7465 _time_steps[i]=MEDFileField1TSWithoutSDA::New(_name.c_str(),i+1,numdt,numo,_infos);
7470 _time_steps[i]=MEDFileIntField1TSWithoutSDA::New(_name.c_str(),i+1,numdt,numo,_infos);
7474 throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::loadStructureOrStructureAndBigArraysRecursively : managed field type are : FLOAT64, INT32 !");
7477 _time_steps[i]->loadStructureAndBigArraysRecursively(fid,*this,ms,entities);
7479 _time_steps[i]->loadOnlyStructureOfDataRecursively(fid,*this,ms,entities);
7480 synchronizeNameScope();
7484 void MEDFileAnyTypeFieldMultiTSWithoutSDA::writeLL(med_idt fid, const MEDFileWritable& opts) const
7486 if(_time_steps.empty())
7487 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::writeLL : no time steps set !");
7488 checkThatNbOfCompoOfTSMatchThis();
7489 std::vector<std::string> infos(getInfo());
7490 int nbComp=infos.size();
7491 INTERP_KERNEL::AutoPtr<char> comp=MEDLoaderBase::buildEmptyString(nbComp*MED_SNAME_SIZE);
7492 INTERP_KERNEL::AutoPtr<char> unit=MEDLoaderBase::buildEmptyString(nbComp*MED_SNAME_SIZE);
7493 for(int i=0;i<nbComp;i++)
7495 std::string info=infos[i];
7497 MEDLoaderBase::splitIntoNameAndUnit(info,c,u);
7498 MEDLoaderBase::safeStrCpy2(c.c_str(),MED_SNAME_SIZE,comp+i*MED_SNAME_SIZE,opts.getTooLongStrPolicy());
7499 MEDLoaderBase::safeStrCpy2(u.c_str(),MED_SNAME_SIZE,unit+i*MED_SNAME_SIZE,opts.getTooLongStrPolicy());
7502 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::write : MED file does not accept field with empty name !");
7503 MEDFILESAFECALLERWR0(MEDfieldCr,(fid,_name.c_str(),getMEDFileFieldType(),nbComp,comp,unit,getDtUnit().c_str(),getMeshName().c_str()));
7504 int nbOfTS=_time_steps.size();
7505 for(int i=0;i<nbOfTS;i++)
7506 _time_steps[i]->writeLL(fid,opts,*this);
7509 void MEDFileAnyTypeFieldMultiTSWithoutSDA::loadBigArraysRecursively(med_idt fid, const MEDFileFieldNameScope& nasc)
7511 for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7513 MEDFileAnyTypeField1TSWithoutSDA *elt(*it);
7515 elt->loadBigArraysRecursively(fid,nasc);
7519 void MEDFileAnyTypeFieldMultiTSWithoutSDA::loadBigArraysRecursivelyIfNecessary(med_idt fid, const MEDFileFieldNameScope& nasc)
7521 for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7523 MEDFileAnyTypeField1TSWithoutSDA *elt(*it);
7525 elt->loadBigArraysRecursivelyIfNecessary(fid,nasc);
7529 void MEDFileAnyTypeFieldMultiTSWithoutSDA::unloadArrays()
7531 for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7533 MEDFileAnyTypeField1TSWithoutSDA *elt(*it);
7535 elt->unloadArrays();
7539 int MEDFileAnyTypeFieldMultiTSWithoutSDA::getNumberOfTS() const
7541 return _time_steps.size();
7544 void MEDFileAnyTypeFieldMultiTSWithoutSDA::eraseEmptyTS()
7546 std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > newTS;
7547 for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7549 const MEDFileAnyTypeField1TSWithoutSDA *tmp=(*it);
7551 newTS.push_back(*it);
7556 void MEDFileAnyTypeFieldMultiTSWithoutSDA::eraseTimeStepIds(const int *startIds, const int *endIds)
7558 std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > newTS;
7559 int maxId=(int)_time_steps.size();
7561 std::set<int> idsToDel;
7562 for(const int *id=startIds;id!=endIds;id++,ii++)
7564 if(*id>=0 && *id<maxId)
7566 idsToDel.insert(*id);
7570 std::ostringstream oss; oss << "MEDFileFieldMultiTSWithoutSDA::eraseTimeStepIds : At pos #" << ii << " request for id=" << *id << " not in [0," << maxId << ") !";
7571 throw INTERP_KERNEL::Exception(oss.str());
7574 for(int iii=0;iii<maxId;iii++)
7575 if(idsToDel.find(iii)==idsToDel.end())
7576 newTS.push_back(_time_steps[iii]);
7580 void MEDFileAnyTypeFieldMultiTSWithoutSDA::eraseTimeStepIds2(int bg, int end, int step)
7582 static const char msg[]="MEDFileAnyTypeFieldMultiTSWithoutSDA::eraseTimeStepIds2";
7583 int nbOfEntriesToKill=DataArrayInt::GetNumberOfItemGivenBESRelative(bg,end,step,msg);
7584 if(nbOfEntriesToKill==0)
7586 std::size_t sz=_time_steps.size();
7587 std::vector<bool> b(sz,true);
7589 for(int i=0;i<nbOfEntriesToKill;i++,j+=step)
7591 std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > newTS;
7592 for(std::size_t i=0;i<sz;i++)
7594 newTS.push_back(_time_steps[i]);
7598 int MEDFileAnyTypeFieldMultiTSWithoutSDA::getPosOfTimeStep(int iteration, int order) const
7601 std::ostringstream oss; oss << "MEDFileFieldMultiTSWithoutSDA::getPosOfTimeStep : No such time step (" << iteration << "," << order << ") !\nPossibilities are : ";
7602 for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,ret++)
7604 const MEDFileAnyTypeField1TSWithoutSDA *tmp(*it);
7608 tmp->getTime(it2,ord);
7609 if(it2==iteration && order==ord)
7612 oss << "(" << it2 << "," << ord << "), ";
7615 throw INTERP_KERNEL::Exception(oss.str());
7618 int MEDFileAnyTypeFieldMultiTSWithoutSDA::getPosGivenTime(double time, double eps) const
7621 std::ostringstream oss; oss << "MEDFileFieldMultiTSWithoutSDA::getPosGivenTime : No such time step " << time << "! \nPossibilities are : ";
7623 for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,ret++)
7625 const MEDFileAnyTypeField1TSWithoutSDA *tmp(*it);
7629 double ti=tmp->getTime(it2,ord);
7630 if(fabs(time-ti)<eps)
7636 throw INTERP_KERNEL::Exception(oss.str());
7639 std::vector< std::pair<int,int> > MEDFileAnyTypeFieldMultiTSWithoutSDA::getIterations() const
7641 int lgth=_time_steps.size();
7642 std::vector< std::pair<int,int> > ret(lgth);
7643 for(int i=0;i<lgth;i++)
7644 _time_steps[i]->fillIteration(ret[i]);
7649 * 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'
7650 * This method returns two things.
7651 * - The absolute dimension of 'this' in first parameter.
7652 * - The available ext levels relative to the absolute dimension returned in first parameter. These relative levels are relative
7653 * to the first output parameter. The values in 'levs' will be returned in decreasing order.
7655 * This method is designed for MEDFileFieldMultiTS instances that have a discritization ON_CELLS, ON_GAUSS_NE and ON_GAUSS.
7656 * Only these 3 discretizations will be taken into account here.
7658 * If 'this' is empty this method will throw an INTERP_KERNEL::Exception.
7659 * If there is \b only node fields defined in 'this' -1 is returned and 'levs' output parameter will be empty. In this
7660 * case the caller has to know the underlying mesh it refers to. By defaut it is the level 0 of the corresponding mesh.
7662 * This method is usefull to make the link between meshDimension of the underlying mesh in 'this' and the levels on 'this'.
7663 * 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'.
7665 * Let's consider the typical following case :
7666 * - a mesh 'm1' has a meshDimension 3 and has the following non empty levels
7667 * [0,-1,-2] for example 'm1' lies on TETRA4, HEXA8 TRI3 and SEG2
7668 * - 'f1' lies on 'm1' and is defined on 3D and 1D cells for example
7670 * - 'f2' lies on 'm1' too and is defined on 2D and 1D cells for example TRI3 and SEG2
7672 * In this case f1->getNonEmptyLevelsExt will return (3,[0,-2]) and f2->getNonEmptyLevelsExt will return (2,[0,-1])
7674 * To retrieve the highest level of f1 it should be done, f1->getFieldAtLevel(ON_CELLS,3-3+0);//absDim-meshDim+relativeLev
7675 * To retrieve the lowest level of f1 it should be done, f1->getFieldAtLevel(ON_CELLS,3-3+(-2));//absDim-meshDim+relativeLev
7676 * To retrieve the highest level of f2 it should be done, f1->getFieldAtLevel(ON_CELLS,2-3+0);//absDim-meshDim+relativeLev
7677 * To retrieve the lowest level of f2 it should be done, f1->getFieldAtLevel(ON_CELLS,2-3+(-1));//absDim-meshDim+relativeLev
7679 int MEDFileAnyTypeFieldMultiTSWithoutSDA::getNonEmptyLevels(int iteration, int order, const std::string& mname, std::vector<int>& levs) const
7681 return getTimeStepEntry(iteration,order).getNonEmptyLevels(mname,levs);
7684 const MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2(int pos) const
7686 if(pos<0 || pos>=(int)_time_steps.size())
7688 std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2 : request for pos #" << pos << " whereas should be in [0," << _time_steps.size() << ") !";
7689 throw INTERP_KERNEL::Exception(oss.str());
7691 const MEDFileAnyTypeField1TSWithoutSDA *item=_time_steps[pos];
7694 std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2 : request for pos #" << pos << ", this pos id exists but the underlying Field1TS is null !";
7695 oss << "\nTry to use following method eraseEmptyTS !";
7696 throw INTERP_KERNEL::Exception(oss.str());
7701 MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2(int pos)
7703 if(pos<0 || pos>=(int)_time_steps.size())
7705 std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2 : request for pos #" << pos << " whereas should be in [0," << _time_steps.size() << ") !";
7706 throw INTERP_KERNEL::Exception(oss.str());
7708 MEDFileAnyTypeField1TSWithoutSDA *item=_time_steps[pos];
7711 std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2 : request for pos #" << pos << ", this pos id exists but the underlying Field1TS is null !";
7712 oss << "\nTry to use following method eraseEmptyTS !";
7713 throw INTERP_KERNEL::Exception(oss.str());
7718 std::vector<std::string> MEDFileAnyTypeFieldMultiTSWithoutSDA::getPflsReallyUsed2() const
7720 std::vector<std::string> ret;
7721 std::set<std::string> ret2;
7722 for(std::vector< MCAuto< MEDFileAnyTypeField1TSWithoutSDA > >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7724 std::vector<std::string> tmp=(*it)->getPflsReallyUsed2();
7725 for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
7726 if(ret2.find(*it2)==ret2.end())
7728 ret.push_back(*it2);
7735 std::vector<std::string> MEDFileAnyTypeFieldMultiTSWithoutSDA::getLocsReallyUsed2() const
7737 std::vector<std::string> ret;
7738 std::set<std::string> ret2;
7739 for(std::vector< MCAuto< MEDFileAnyTypeField1TSWithoutSDA > >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7741 std::vector<std::string> tmp=(*it)->getLocsReallyUsed2();
7742 for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
7743 if(ret2.find(*it2)==ret2.end())
7745 ret.push_back(*it2);
7752 std::vector<std::string> MEDFileAnyTypeFieldMultiTSWithoutSDA::getPflsReallyUsedMulti2() const
7754 std::vector<std::string> ret;
7755 for(std::vector< MCAuto< MEDFileAnyTypeField1TSWithoutSDA > >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7757 std::vector<std::string> tmp=(*it)->getPflsReallyUsedMulti2();
7758 ret.insert(ret.end(),tmp.begin(),tmp.end());
7763 std::vector<std::string> MEDFileAnyTypeFieldMultiTSWithoutSDA::getLocsReallyUsedMulti2() const
7765 std::vector<std::string> ret;
7766 for(std::vector< MCAuto< MEDFileAnyTypeField1TSWithoutSDA > >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7768 std::vector<std::string> tmp=(*it)->getLocsReallyUsedMulti2();
7769 ret.insert(ret.end(),tmp.begin(),tmp.end());
7774 void MEDFileAnyTypeFieldMultiTSWithoutSDA::changePflsRefsNamesGen2(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
7776 for(std::vector< MCAuto< MEDFileAnyTypeField1TSWithoutSDA > >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7777 (*it)->changePflsRefsNamesGen2(mapOfModif);
7780 void MEDFileAnyTypeFieldMultiTSWithoutSDA::changeLocsRefsNamesGen2(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
7782 for(std::vector< MCAuto< MEDFileAnyTypeField1TSWithoutSDA > >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7783 (*it)->changeLocsRefsNamesGen2(mapOfModif);
7786 std::vector< std::vector<TypeOfField> > MEDFileAnyTypeFieldMultiTSWithoutSDA::getTypesOfFieldAvailable() const
7788 int lgth=_time_steps.size();
7789 std::vector< std::vector<TypeOfField> > ret(lgth);
7790 for(int i=0;i<lgth;i++)
7791 _time_steps[i]->fillTypesOfFieldAvailable(ret[i]);
7796 * entry point for users that want to iterate into MEDFile DataStructure without any overhead.
7798 std::vector< std::vector< std::pair<int,int> > > MEDFileAnyTypeFieldMultiTSWithoutSDA::getFieldSplitedByType(int iteration, int order, const std::string& 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
7800 return getTimeStepEntry(iteration,order).getFieldSplitedByType(mname,types,typesF,pfls,locs);
7803 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::deepCopy() const
7805 MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> ret=shallowCpy();
7807 for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,i++)
7809 if((const MEDFileAnyTypeField1TSWithoutSDA *)*it)
7810 ret->_time_steps[i]=(*it)->deepCopy();
7815 std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> > MEDFileAnyTypeFieldMultiTSWithoutSDA::splitComponents() const
7817 std::size_t sz(_infos.size()),sz2(_time_steps.size());
7818 std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> > ret(sz);
7819 std::vector< std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > > ts(sz2);
7820 for(std::size_t i=0;i<sz;i++)
7822 ret[i]=shallowCpy();
7823 ret[i]->_infos.resize(1); ret[i]->_infos[0]=_infos[i];
7825 for(std::size_t i=0;i<sz2;i++)
7827 std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > ret1=_time_steps[i]->splitComponents();
7830 std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::splitComponents : At rank #" << i << " number of components is " << ret1.size() << " whereas it should be for all time steps " << sz << " !";
7831 throw INTERP_KERNEL::Exception(oss.str());
7835 for(std::size_t i=0;i<sz;i++)
7836 for(std::size_t j=0;j<sz2;j++)
7837 ret[i]->_time_steps[j]=ts[j][i];
7842 * This method splits into discretization each time steps in \a this.
7843 * ** WARNING ** the returned instances are not compulsary defined on the same time steps series !
7845 std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> > MEDFileAnyTypeFieldMultiTSWithoutSDA::splitDiscretizations() const
7847 std::size_t sz(_time_steps.size());
7848 std::vector< std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > > items(sz);
7849 for(std::size_t i=0;i<sz;i++)
7851 const MEDFileAnyTypeField1TSWithoutSDA *timeStep(_time_steps[i]);
7854 std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::splitDiscretizations : time step #" << i << " is null !";
7855 throw INTERP_KERNEL::Exception(oss.str());
7857 items[i]=timeStep->splitDiscretizations();
7860 std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> > ret;
7861 std::vector< std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > > ret2;
7862 std::vector< TypeOfField > types;
7863 for(std::vector< std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > >::const_iterator it0=items.begin();it0!=items.end();it0++)
7864 for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++)
7866 std::vector<TypeOfField> ts=(*it1)->getTypesOfFieldAvailable();
7868 throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::splitDiscretizations : it appears that the splitting of MEDFileAnyTypeField1TSWithoutSDA::splitDiscretizations has returned invalid result !");
7869 std::vector< TypeOfField >::iterator it2=std::find(types.begin(),types.end(),ts[0]);
7870 if(it2==types.end())
7871 types.push_back(ts[0]);
7873 ret.resize(types.size()); ret2.resize(types.size());
7874 for(std::vector< std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > >::const_iterator it0=items.begin();it0!=items.end();it0++)
7875 for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++)
7877 TypeOfField typ=(*it1)->getTypesOfFieldAvailable()[0];
7878 std::size_t pos=std::distance(types.begin(),std::find(types.begin(),types.end(),typ));
7879 ret2[pos].push_back(*it1);
7881 for(std::size_t i=0;i<types.size();i++)
7883 MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> elt(createNew());
7884 for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it1=ret2[i].begin();it1!=ret2[i].end();it1++)
7885 elt->pushBackTimeStep(*it1);//also updates infos in elt
7887 elt->MEDFileFieldNameScope::operator=(*this);
7893 * Contrary to splitDiscretizations method this method makes the hypothesis that the times series are **NOT** impacted by the splitting of multi discretization.
7895 std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> > MEDFileAnyTypeFieldMultiTSWithoutSDA::splitMultiDiscrPerGeoTypes() const
7897 std::size_t sz(_time_steps.size());
7898 std::vector< std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> > > items(sz);
7899 std::size_t szOut(std::numeric_limits<std::size_t>::max());
7900 for(std::size_t i=0;i<sz;i++)
7902 const MEDFileAnyTypeField1TSWithoutSDA *timeStep(_time_steps[i]);
7905 std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::splitMultiDiscrPerGeoTypes : time step #" << i << " is null !";
7906 throw INTERP_KERNEL::Exception(oss.str());
7908 items[i]=timeStep->splitMultiDiscrPerGeoTypes();
7909 if(szOut==std::numeric_limits<std::size_t>::max())
7910 szOut=items[i].size();
7912 if(items[i].size()!=szOut)
7913 throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::splitMultiDiscrPerGeoTypes : The splitting per discretization is expected to be same among time steps !");
7915 if(szOut==std::numeric_limits<std::size_t>::max())
7916 throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::splitMultiDiscrPerGeoTypes : empty field !");
7917 std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> > ret(szOut);
7918 for(std::size_t i=0;i<szOut;i++)
7920 MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> elt(createNew());
7921 for(std::size_t j=0;j<sz;j++)
7922 elt->pushBackTimeStep(items[j][i]);
7924 elt->MEDFileFieldNameScope::operator=(*this);
7929 void MEDFileAnyTypeFieldMultiTSWithoutSDA::copyTinyInfoFrom(const MEDCouplingFieldDouble *field, const DataArray *arr)
7931 _name=field->getName();
7933 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::copyTinyInfoFrom : unsupported fields with no name in MED file !");
7935 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::copyTinyInfoFrom : no array set !");
7936 _infos=arr->getInfoOnComponents();
7939 void MEDFileAnyTypeFieldMultiTSWithoutSDA::checkCoherencyOfTinyInfo(const MEDCouplingFieldDouble *field, const DataArray *arr) const
7941 static const char MSG[]="MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfTinyInfo : invalid ";
7942 if(_name!=field->getName())
7944 std::ostringstream oss; oss << MSG << "name ! should be \"" << _name;
7945 oss << "\" and it is set in input field to \"" << field->getName() << "\" !";
7946 throw INTERP_KERNEL::Exception(oss.str());
7949 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfTinyInfo : no array set !");
7950 checkThatComponentsMatch(arr->getInfoOnComponents());
7953 void MEDFileAnyTypeFieldMultiTSWithoutSDA::checkThatComponentsMatch(const std::vector<std::string>& compos) const
7955 static const char MSG[]="MEDFileFieldMultiTSWithoutSDA::checkThatComponentsMatch : ";
7956 if(getInfo().size()!=compos.size())
7958 std::ostringstream oss; oss << MSG << "mismatch of number of components between this (" << getInfo().size() << ") and ";
7959 oss << " number of components of element to append (" << compos.size() << ") !";
7960 throw INTERP_KERNEL::Exception(oss.str());
7964 std::ostringstream oss; oss << MSG << "components have same size but are different ! should be \"";
7965 std::copy(_infos.begin(),_infos.end(),std::ostream_iterator<std::string>(oss,", "));
7966 oss << " But compo in input fields are : ";
7967 std::copy(compos.begin(),compos.end(),std::ostream_iterator<std::string>(oss,", "));
7969 throw INTERP_KERNEL::Exception(oss.str());
7973 void MEDFileAnyTypeFieldMultiTSWithoutSDA::checkThatNbOfCompoOfTSMatchThis() const
7975 std::size_t sz=_infos.size();
7977 for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,j++)
7979 const MEDFileAnyTypeField1TSWithoutSDA *elt(*it);
7981 if(elt->getInfo().size()!=sz)
7983 std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::checkThatNbOfCompoOfTSMatchThis : At pos #" << j << " the number of components is equal to ";
7984 oss << elt->getInfo().size() << " whereas it is expected to be equal to " << sz << " !";
7985 throw INTERP_KERNEL::Exception(oss.str());
7990 void MEDFileAnyTypeFieldMultiTSWithoutSDA::appendFieldNoProfileSBT(const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob)
7993 throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::appendFieldNoProfileSBT : input field is NULL !");
7994 if(!_time_steps.empty())
7995 checkCoherencyOfTinyInfo(field,arr);
7996 MEDFileAnyTypeField1TSWithoutSDA *objC=createNew1TSWithoutSDAEmptyInstance();
7997 MCAuto<MEDFileAnyTypeField1TSWithoutSDA> obj(objC);
7998 objC->setFieldNoProfileSBT(field,arr,glob,*this);
7999 copyTinyInfoFrom(field,arr);
8000 _time_steps.push_back(obj);
8003 void MEDFileAnyTypeFieldMultiTSWithoutSDA::appendFieldProfile(const MEDCouplingFieldDouble *field, const DataArray *arr, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile, MEDFileFieldGlobsReal& glob)
8006 throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTSWithoutSDA::appendFieldNoProfileSBT : input field is NULL !");
8007 if(!_time_steps.empty())
8008 checkCoherencyOfTinyInfo(field,arr);
8009 MEDFileAnyTypeField1TSWithoutSDA *objC=createNew1TSWithoutSDAEmptyInstance();
8010 MCAuto<MEDFileAnyTypeField1TSWithoutSDA> obj(objC);
8011 objC->setFieldProfile(field,arr,mesh,meshDimRelToMax,profile,glob,*this);
8012 copyTinyInfoFrom(field,arr);
8013 _time_steps.push_back(obj);
8016 void MEDFileAnyTypeFieldMultiTSWithoutSDA::setIteration(int i, MCAuto<MEDFileAnyTypeField1TSWithoutSDA> ts)
8018 int sz=(int)_time_steps.size();
8021 std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::setIteration : trying to set element at place #" << i << " should be in [0," << sz << ") !";
8022 throw INTERP_KERNEL::Exception(oss.str());
8024 const MEDFileAnyTypeField1TSWithoutSDA *tsPtr(ts);
8027 if(tsPtr->getNumberOfComponents()!=(int)_infos.size())
8029 std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::setIteration : trying to set element with " << tsPtr->getNumberOfComponents() << " components ! Should be " << _infos.size() << " !";
8030 throw INTERP_KERNEL::Exception(oss.str());
8036 //= MEDFileFieldMultiTSWithoutSDA
8038 MEDFileFieldMultiTSWithoutSDA *MEDFileFieldMultiTSWithoutSDA::New(med_idt fid, const std::string& fieldName, med_field_type fieldTyp, const std::vector<std::string>& infos, int nbOfStep, const std::string& dtunit, bool loadAll, const MEDFileMeshes *ms, const std::vector< std::pair<TypeOfField,INTERP_KERNEL::NormalizedCellType> > *entities)
8040 return new MEDFileFieldMultiTSWithoutSDA(fid,fieldName,fieldTyp,infos,nbOfStep,dtunit,loadAll,ms,entities);
8043 MEDFileFieldMultiTSWithoutSDA::MEDFileFieldMultiTSWithoutSDA()
8047 MEDFileFieldMultiTSWithoutSDA::MEDFileFieldMultiTSWithoutSDA(const std::string& fieldName):MEDFileAnyTypeFieldMultiTSWithoutSDA(fieldName)
8052 * \param [in] fieldId field id in C mode
8054 MEDFileFieldMultiTSWithoutSDA::MEDFileFieldMultiTSWithoutSDA(med_idt fid, int fieldId, bool loadAll, const MEDFileMeshes *ms, const std::vector< std::pair<TypeOfField,INTERP_KERNEL::NormalizedCellType> > *entities)
8055 try:MEDFileAnyTypeFieldMultiTSWithoutSDA(fid,fieldId,loadAll,ms,entities)
8058 catch(INTERP_KERNEL::Exception& e)
8061 MEDFileFieldMultiTSWithoutSDA::MEDFileFieldMultiTSWithoutSDA(med_idt fid, const std::string& fieldName, med_field_type fieldTyp, const std::vector<std::string>& infos, int nbOfStep, const std::string& dtunit, bool loadAll, const MEDFileMeshes *ms, const std::vector< std::pair<TypeOfField,INTERP_KERNEL::NormalizedCellType> > *entities)
8062 try:MEDFileAnyTypeFieldMultiTSWithoutSDA(fid,fieldName,fieldTyp,infos,nbOfStep,dtunit,loadAll,ms,entities)
8065 catch(INTERP_KERNEL::Exception& e)
8068 MEDFileAnyTypeField1TSWithoutSDA *MEDFileFieldMultiTSWithoutSDA::createNew1TSWithoutSDAEmptyInstance() const
8070 return new MEDFileField1TSWithoutSDA;
8073 void MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfType(const MEDFileAnyTypeField1TSWithoutSDA *f1ts) const
8076 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfType : input field1TS is NULL ! Impossible to check !");
8077 const MEDFileField1TSWithoutSDA *f1tsC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(f1ts);
8079 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfType : the input field1TS is not a FLOAT64 type !");
8082 const char *MEDFileFieldMultiTSWithoutSDA::getTypeStr() const
8084 return MEDFileField1TSWithoutSDA::TYPE_STR;
8087 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileFieldMultiTSWithoutSDA::shallowCpy() const
8089 return new MEDFileFieldMultiTSWithoutSDA(*this);
8092 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileFieldMultiTSWithoutSDA::createNew() const
8094 return new MEDFileFieldMultiTSWithoutSDA;
8098 * entry point for users that want to iterate into MEDFile DataStructure with a reduced overhead because output arrays are extracted (created) specially
8099 * for the call of this method. That's why the DataArrayDouble instance in returned vector of vector should be dealed by the caller.
8101 std::vector< std::vector<DataArrayDouble *> > MEDFileFieldMultiTSWithoutSDA::getFieldSplitedByType2(int iteration, int order, const std::string& 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
8103 const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=getTimeStepEntry(iteration,order);
8104 const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
8106 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::getFieldSplitedByType2 : mismatch of type of field expecting FLOAT64 !");
8107 return myF1TSC->getFieldSplitedByType2(mname,types,typesF,pfls,locs);
8110 MEDFileIntFieldMultiTSWithoutSDA *MEDFileFieldMultiTSWithoutSDA::convertToInt() const
8112 MCAuto<MEDFileIntFieldMultiTSWithoutSDA> ret(new MEDFileIntFieldMultiTSWithoutSDA);
8113 ret->MEDFileAnyTypeFieldMultiTSWithoutSDA::operator =(*this);
8115 for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,i++)
8117 const MEDFileAnyTypeField1TSWithoutSDA *eltToConv(*it);
8120 const MEDFileField1TSWithoutSDA *eltToConvC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(eltToConv);
8122 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::convertToInt : presence of an invalid 1TS type ! Should be of type FLOAT64 !");
8123 MCAuto<MEDFileAnyTypeField1TSWithoutSDA> elt=eltToConvC->convertToInt();
8124 ret->setIteration(i,elt);
8130 //= MEDFileAnyTypeFieldMultiTS
8132 MEDFileAnyTypeFieldMultiTS::MEDFileAnyTypeFieldMultiTS()
8136 MEDFileAnyTypeFieldMultiTS::MEDFileAnyTypeFieldMultiTS(med_idt fid, bool loadAll, const MEDFileMeshes *ms)
8137 try:MEDFileFieldGlobsReal(fid)
8139 _content=BuildContentFrom(fid,loadAll,ms);
8142 catch(INTERP_KERNEL::Exception& e)
8147 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTS::BuildContentFrom(med_idt fid, const std::string& fieldName, bool loadAll, const MEDFileMeshes *ms, const std::vector< std::pair<TypeOfField,INTERP_KERNEL::NormalizedCellType> > *entities)
8149 med_field_type typcha;
8150 std::vector<std::string> infos;
8153 MEDFileAnyTypeField1TS::LocateField(fid,fieldName,i,typcha,infos,dtunit);
8154 MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> ret;
8159 ret=new MEDFileFieldMultiTSWithoutSDA(fid,i,loadAll,ms,entities);
8164 ret=new MEDFileIntFieldMultiTSWithoutSDA(fid,i,loadAll,ms,entities);
8169 std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTS::BuildContentFrom(fid,fieldName) : file \'" << FileNameFromFID(fid) << "\' contains field with name \'" << fieldName << "\' but the type of field is not in [MED_FLOAT64, MED_INT32] !";
8170 throw INTERP_KERNEL::Exception(oss.str());
8173 ret->setDtUnit(dtunit.c_str());
8177 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTS::BuildContentFrom(med_idt fid, bool loadAll, const MEDFileMeshes *ms)
8179 med_field_type typcha;
8181 std::vector<std::string> infos;
8182 std::string dtunit,fieldName;
8183 MEDFileAnyTypeField1TS::LocateField2(fid,0,true,fieldName,typcha,infos,dtunit);
8184 MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> ret;
8189 ret=new MEDFileFieldMultiTSWithoutSDA(fid,0,loadAll,ms,0);
8194 ret=new MEDFileIntFieldMultiTSWithoutSDA(fid,0,loadAll,ms,0);
8199 std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTS::BuildContentFrom(fid) : file \'" << FileNameFromFID(fid) << "\' contains field with name \'" << fieldName << "\' but the type of the first field is not in [MED_FLOAT64, MED_INT32] !";
8200 throw INTERP_KERNEL::Exception(oss.str());
8203 ret->setDtUnit(dtunit.c_str());
8207 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent(MEDFileAnyTypeFieldMultiTSWithoutSDA *c, const std::string& fileName)
8210 throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent : empty content in input : unable to build a new instance !");
8211 if(dynamic_cast<const MEDFileFieldMultiTSWithoutSDA *>(c))
8213 MCAuto<MEDFileFieldMultiTS> ret(MEDFileFieldMultiTS::New());
8214 ret->setFileName(fileName);
8215 ret->_content=c; c->incrRef();
8218 if(dynamic_cast<const MEDFileIntFieldMultiTSWithoutSDA *>(c))
8220 MCAuto<MEDFileIntFieldMultiTS> ret(MEDFileIntFieldMultiTS::New());
8221 ret->setFileName(fileName);
8222 ret->_content=c; c->incrRef();
8225 throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent : internal error ! a content of type different from FLOAT64 and INT32 has been built but not intercepted !");
8228 MEDFileAnyTypeFieldMultiTS::MEDFileAnyTypeFieldMultiTS(med_idt fid, const std::string& fieldName, bool loadAll, const MEDFileMeshes *ms, const std::vector< std::pair<TypeOfField,INTERP_KERNEL::NormalizedCellType> > *entities)
8229 try:MEDFileFieldGlobsReal(fid)
8231 _content=BuildContentFrom(fid,fieldName,loadAll,ms,entities);
8234 catch(INTERP_KERNEL::Exception& e)
8239 //= MEDFileIntFieldMultiTSWithoutSDA
8241 MEDFileIntFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTSWithoutSDA::New(med_idt fid, const std::string& fieldName, med_field_type fieldTyp, const std::vector<std::string>& infos, int nbOfStep, const std::string& dtunit, bool loadAll, const MEDFileMeshes *ms, const std::vector< std::pair<TypeOfField,INTERP_KERNEL::NormalizedCellType> > *entities)
8243 return new MEDFileIntFieldMultiTSWithoutSDA(fid,fieldName,fieldTyp,infos,nbOfStep,dtunit,loadAll,ms,entities);
8246 MEDFileIntFieldMultiTSWithoutSDA::MEDFileIntFieldMultiTSWithoutSDA()
8250 MEDFileIntFieldMultiTSWithoutSDA::MEDFileIntFieldMultiTSWithoutSDA(const std::string& fieldName):MEDFileAnyTypeFieldMultiTSWithoutSDA(fieldName)
8254 MEDFileIntFieldMultiTSWithoutSDA::MEDFileIntFieldMultiTSWithoutSDA(med_idt fid, const std::string& fieldName, med_field_type fieldTyp, const std::vector<std::string>& infos, int nbOfStep, const std::string& dtunit, bool loadAll, const MEDFileMeshes *ms, const std::vector< std::pair<TypeOfField,INTERP_KERNEL::NormalizedCellType> > *entities)
8255 try:MEDFileAnyTypeFieldMultiTSWithoutSDA(fid,fieldName,fieldTyp,infos,nbOfStep,dtunit,loadAll,ms,entities)
8258 catch(INTERP_KERNEL::Exception& e)
8262 * \param [in] fieldId field id in C mode
8264 MEDFileIntFieldMultiTSWithoutSDA::MEDFileIntFieldMultiTSWithoutSDA(med_idt fid, int fieldId, bool loadAll, const MEDFileMeshes *ms, const std::vector< std::pair<TypeOfField,INTERP_KERNEL::NormalizedCellType> > *entities)
8265 try:MEDFileAnyTypeFieldMultiTSWithoutSDA(fid,fieldId,loadAll,ms,entities)
8268 catch(INTERP_KERNEL::Exception& e)
8271 MEDFileAnyTypeField1TSWithoutSDA *MEDFileIntFieldMultiTSWithoutSDA::createNew1TSWithoutSDAEmptyInstance() const
8273 return new MEDFileIntField1TSWithoutSDA;
8276 void MEDFileIntFieldMultiTSWithoutSDA::checkCoherencyOfType(const MEDFileAnyTypeField1TSWithoutSDA *f1ts) const
8279 throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTSWithoutSDA::checkCoherencyOfType : input field1TS is NULL ! Impossible to check !");
8280 const MEDFileIntField1TSWithoutSDA *f1tsC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(f1ts);
8282 throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTSWithoutSDA::checkCoherencyOfType : the input field1TS is not a INT32 type !");
8285 const char *MEDFileIntFieldMultiTSWithoutSDA::getTypeStr() const
8287 return MEDFileIntField1TSWithoutSDA::TYPE_STR;
8290 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTSWithoutSDA::shallowCpy() const
8292 return new MEDFileIntFieldMultiTSWithoutSDA(*this);
8295 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTSWithoutSDA::createNew() const
8297 return new MEDFileIntFieldMultiTSWithoutSDA;
8300 MEDFileFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTSWithoutSDA::convertToDouble() const
8302 MCAuto<MEDFileFieldMultiTSWithoutSDA> ret(new MEDFileFieldMultiTSWithoutSDA);
8303 ret->MEDFileAnyTypeFieldMultiTSWithoutSDA::operator =(*this);
8305 for(std::vector< MCAuto<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,i++)
8307 const MEDFileAnyTypeField1TSWithoutSDA *eltToConv(*it);
8310 const MEDFileIntField1TSWithoutSDA *eltToConvC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(eltToConv);
8312 throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTSWithoutSDA::convertToInt : presence of an invalid 1TS type ! Should be of type INT32 !");
8313 MCAuto<MEDFileAnyTypeField1TSWithoutSDA> elt=eltToConvC->convertToDouble();
8314 ret->setIteration(i,elt);
8320 //= MEDFileAnyTypeFieldMultiTS
8323 * Returns a new instance of MEDFileFieldMultiTS or MEDFileIntFieldMultiTS holding data of the first field
8324 * that has been read from a specified MED file.
8325 * \param [in] fileName - the name of the MED file to read.
8326 * \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS or MEDFileIntFieldMultiTS. The caller
8327 * is to delete this field using decrRef() as it is no more needed.
8328 * \throw If reading the file fails.
8330 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::New(const std::string& fileName, bool loadAll)
8332 MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
8333 MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> c(BuildContentFrom(fid,loadAll,0));
8334 MCAuto<MEDFileAnyTypeFieldMultiTS> ret(BuildNewInstanceFromContent(c,fileName));
8335 ret->loadGlobals(fid);
8340 * Returns a new instance of MEDFileFieldMultiTS or MEDFileIntFieldMultiTS holding data of a given field
8341 * that has been read from a specified MED file.
8342 * \param [in] fileName - the name of the MED file to read.
8343 * \param [in] fieldName - the name of the field to read.
8344 * \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS or MEDFileIntFieldMultiTS. The caller
8345 * is to delete this field using decrRef() as it is no more needed.
8346 * \throw If reading the file fails.
8347 * \throw If there is no field named \a fieldName in the file.
8349 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::New(const std::string& fileName, const std::string& fieldName, bool loadAll)
8351 MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
8352 MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> c(BuildContentFrom(fid,fieldName,loadAll,0,0));
8353 MCAuto<MEDFileAnyTypeFieldMultiTS> ret=BuildNewInstanceFromContent(c,fileName);
8354 ret->loadGlobals(fid);
8359 * This constructor is a shallow copy constructor. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
8360 * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
8362 * \warning this is a shallow copy constructor
8364 MEDFileAnyTypeFieldMultiTS::MEDFileAnyTypeFieldMultiTS(const MEDFileAnyTypeFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent)
8366 if(!shallowCopyOfContent)
8368 const MEDFileAnyTypeFieldMultiTSWithoutSDA *otherPtr(&other);
8369 otherPtr->incrRef();
8370 _content=const_cast<MEDFileAnyTypeFieldMultiTSWithoutSDA *>(otherPtr);
8374 _content=other.shallowCpy();
8378 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTS::contentNotNullBase()
8380 MEDFileAnyTypeFieldMultiTSWithoutSDA *ret=_content;
8382 throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS : content is expected to be not null !");
8386 const MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTS::contentNotNullBase() const
8388 const MEDFileAnyTypeFieldMultiTSWithoutSDA *ret=_content;
8390 throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS : const content is expected to be not null !");
8394 std::vector<std::string> MEDFileAnyTypeFieldMultiTS::getPflsReallyUsed() const
8396 return contentNotNullBase()->getPflsReallyUsed2();
8399 std::vector<std::string> MEDFileAnyTypeFieldMultiTS::getLocsReallyUsed() const
8401 return contentNotNullBase()->getLocsReallyUsed2();
8404 std::vector<std::string> MEDFileAnyTypeFieldMultiTS::getPflsReallyUsedMulti() const
8406 return contentNotNullBase()->getPflsReallyUsedMulti2();
8409 std::vector<std::string> MEDFileAnyTypeFieldMultiTS::getLocsReallyUsedMulti() const
8411 return contentNotNullBase()->getLocsReallyUsedMulti2();
8414 void MEDFileAnyTypeFieldMultiTS::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
8416 contentNotNullBase()->changePflsRefsNamesGen2(mapOfModif);
8419 void MEDFileAnyTypeFieldMultiTS::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
8421 contentNotNullBase()->changeLocsRefsNamesGen2(mapOfModif);
8424 int MEDFileAnyTypeFieldMultiTS::getNumberOfTS() const
8426 return contentNotNullBase()->getNumberOfTS();
8429 void MEDFileAnyTypeFieldMultiTS::eraseEmptyTS()
8431 contentNotNullBase()->eraseEmptyTS();
8434 void MEDFileAnyTypeFieldMultiTS::eraseTimeStepIds(const int *startIds, const int *endIds)
8436 contentNotNullBase()->eraseTimeStepIds(startIds,endIds);
8439 void MEDFileAnyTypeFieldMultiTS::eraseTimeStepIds2(int bg, int end, int step)
8441 contentNotNullBase()->eraseTimeStepIds2(bg,end,step);
8444 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::buildSubPart(const int *startIds, const int *endIds) const
8446 MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> c=contentNotNullBase()->buildFromTimeStepIds(startIds,endIds);
8447 MCAuto<MEDFileAnyTypeFieldMultiTS> ret=shallowCpy();
8452 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::buildSubPartSlice(int bg, int end, int step) const
8454 MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> c=contentNotNullBase()->buildFromTimeStepIds2(bg,end,step);
8455 MCAuto<MEDFileAnyTypeFieldMultiTS> ret=shallowCpy();
8460 std::vector< std::pair<int,int> > MEDFileAnyTypeFieldMultiTS::getIterations() const
8462 return contentNotNullBase()->getIterations();
8465 void MEDFileAnyTypeFieldMultiTS::pushBackTimeSteps(const std::vector<MEDFileAnyTypeField1TS *>& f1ts)
8467 for(std::vector<MEDFileAnyTypeField1TS *>::const_iterator it=f1ts.begin();it!=f1ts.end();it++)
8468 pushBackTimeStep(*it);
8471 void MEDFileAnyTypeFieldMultiTS::pushBackTimeSteps(MEDFileAnyTypeFieldMultiTS *fmts)
8474 throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::pushBackTimeSteps : Input fmts is NULL !");
8475 int nbOfTS(fmts->getNumberOfTS());
8476 for(int i=0;i<nbOfTS;i++)
8478 MCAuto<MEDFileAnyTypeField1TS> elt(fmts->getTimeStepAtPos(i));
8479 pushBackTimeStep(elt);
8483 void MEDFileAnyTypeFieldMultiTS::pushBackTimeStep(MEDFileAnyTypeField1TS *f1ts)
8486 throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::pushBackTimeStep : input pointer is NULL !");
8487 checkCoherencyOfType(f1ts);
8489 MCAuto<MEDFileAnyTypeField1TS> f1tsSafe(f1ts);
8490 MEDFileAnyTypeField1TSWithoutSDA *c=f1ts->contentNotNullBase();
8492 MCAuto<MEDFileAnyTypeField1TSWithoutSDA> cSafe(c);
8493 if(!((MEDFileAnyTypeFieldMultiTSWithoutSDA *)_content))
8494 throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::pushBackTimeStep : no content in this !");
8495 _content->pushBackTimeStep(cSafe);
8496 appendGlobs(*f1ts,1e-12);
8499 void MEDFileAnyTypeFieldMultiTS::synchronizeNameScope()
8501 contentNotNullBase()->synchronizeNameScope();
8504 int MEDFileAnyTypeFieldMultiTS::getPosOfTimeStep(int iteration, int order) const
8506 return contentNotNullBase()->getPosOfTimeStep(iteration,order);
8509 int MEDFileAnyTypeFieldMultiTS::getPosGivenTime(double time, double eps) const
8511 return contentNotNullBase()->getPosGivenTime(time,eps);
8514 int MEDFileAnyTypeFieldMultiTS::getNonEmptyLevels(int iteration, int order, const std::string& mname, std::vector<int>& levs) const
8516 return contentNotNullBase()->getNonEmptyLevels(iteration,order,mname,levs);
8519 std::vector< std::vector<TypeOfField> > MEDFileAnyTypeFieldMultiTS::getTypesOfFieldAvailable() const
8521 return contentNotNullBase()->getTypesOfFieldAvailable();
8524 std::vector< std::vector< std::pair<int,int> > > MEDFileAnyTypeFieldMultiTS::getFieldSplitedByType(int iteration, int order, const std::string& 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
8526 return contentNotNullBase()->getFieldSplitedByType(iteration,order,mname,types,typesF,pfls,locs);
8529 std::string MEDFileAnyTypeFieldMultiTS::getName() const
8531 return contentNotNullBase()->getName();
8534 void MEDFileAnyTypeFieldMultiTS::setName(const std::string& name)
8536 contentNotNullBase()->setName(name);
8539 std::string MEDFileAnyTypeFieldMultiTS::getDtUnit() const
8541 return contentNotNullBase()->getDtUnit();
8544 void MEDFileAnyTypeFieldMultiTS::setDtUnit(const std::string& dtUnit)
8546 contentNotNullBase()->setDtUnit(dtUnit);
8549 void MEDFileAnyTypeFieldMultiTS::simpleRepr(int bkOffset, std::ostream& oss, int fmtsId) const
8551 contentNotNullBase()->simpleRepr(bkOffset,oss,fmtsId);
8554 std::vector< std::pair<int,int> > MEDFileAnyTypeFieldMultiTS::getTimeSteps(std::vector<double>& ret1) const
8556 return contentNotNullBase()->getTimeSteps(ret1);
8559 std::string MEDFileAnyTypeFieldMultiTS::getMeshName() const
8561 return contentNotNullBase()->getMeshName();
8564 void MEDFileAnyTypeFieldMultiTS::setMeshName(const std::string& newMeshName)
8566 contentNotNullBase()->setMeshName(newMeshName);
8569 bool MEDFileAnyTypeFieldMultiTS::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab)
8571 return contentNotNullBase()->changeMeshNames(modifTab);
8574 const std::vector<std::string>& MEDFileAnyTypeFieldMultiTS::getInfo() const
8576 return contentNotNullBase()->getInfo();
8579 bool MEDFileAnyTypeFieldMultiTS::presenceOfMultiDiscPerGeoType() const
8581 return contentNotNullBase()->presenceOfMultiDiscPerGeoType();
8584 void MEDFileAnyTypeFieldMultiTS::setInfo(const std::vector<std::string>& info)
8586 return contentNotNullBase()->setInfo(info);
8589 int MEDFileAnyTypeFieldMultiTS::getNumberOfComponents() const
8591 const std::vector<std::string> ret=getInfo();
8592 return (int)ret.size();
8595 void MEDFileAnyTypeFieldMultiTS::writeLL(med_idt fid) const
8597 writeGlobals(fid,*this);
8598 contentNotNullBase()->writeLL(fid,*this);
8602 * This method alloc the arrays and load potentially huge arrays contained in this field.
8603 * This method should be called when a MEDFileAnyTypeFieldMultiTS::New constructor has been with false as the last parameter.
8604 * This method can be also called to refresh or reinit values from a file.
8606 * \throw If the fileName is not set or points to a non readable MED file.
8608 void MEDFileAnyTypeFieldMultiTS::loadArrays()
8610 if(getFileName().empty())
8611 throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::loadArrays : the structure does not come from a file !");
8612 MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(getFileName()));
8613 contentNotNullBase()->loadBigArraysRecursively(fid,*contentNotNullBase());
8617 * This method behaves as MEDFileAnyTypeFieldMultiTS::loadArrays does, the first call, if \a this was built using a file without loading big arrays.
8618 * But once data loaded once, this method does nothing.
8620 * \throw If the fileName is not set or points to a non readable MED file.
8621 * \sa MEDFileAnyTypeFieldMultiTS::loadArrays, MEDFileAnyTypeFieldMultiTS::unloadArrays
8623 void MEDFileAnyTypeFieldMultiTS::loadArraysIfNecessary()
8625 if(!getFileName().empty())
8627 MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(getFileName()));
8628 contentNotNullBase()->loadBigArraysRecursivelyIfNecessary(fid,*contentNotNullBase());
8633 * This method releases potentially big data arrays and so returns to the same heap memory than status loaded with 'loadAll' parameter set to false.
8634 * \b WARNING, this method does release arrays even if \a this does not come from a load of a MED file.
8635 * So this method can lead to a loss of data. If you want to unload arrays safely call MEDFileAnyTypeFieldMultiTS::unloadArraysWithoutDataLoss instead.
8637 * \sa MEDFileAnyTypeFieldMultiTS::loadArrays, MEDFileAnyTypeFieldMultiTS::loadArraysIfNecessary, MEDFileAnyTypeFieldMultiTS::unloadArraysWithoutDataLoss
8639 void MEDFileAnyTypeFieldMultiTS::unloadArrays()
8641 contentNotNullBase()->unloadArrays();
8645 * 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.
8646 * This method is the symetrical method of MEDFileAnyTypeFieldMultiTS::loadArraysIfNecessary.
8647 * This method is useful to reduce \b safely amount of heap memory necessary for \a this by using MED file as database.
8649 * \sa MEDFileAnyTypeFieldMultiTS::loadArraysIfNecessary
8651 void MEDFileAnyTypeFieldMultiTS::unloadArraysWithoutDataLoss()
8653 if(!getFileName().empty())
8654 contentNotNullBase()->unloadArrays();
8657 std::string MEDFileAnyTypeFieldMultiTS::simpleRepr() const
8659 std::ostringstream oss;
8660 contentNotNullBase()->simpleRepr(0,oss,-1);
8661 simpleReprGlobs(oss);
8665 std::size_t MEDFileAnyTypeFieldMultiTS::getHeapMemorySizeWithoutChildren() const
8667 return MEDFileFieldGlobsReal::getHeapMemorySizeWithoutChildren();
8670 std::vector<const BigMemoryObject *> MEDFileAnyTypeFieldMultiTS::getDirectChildrenWithNull() const
8672 std::vector<const BigMemoryObject *> ret(MEDFileFieldGlobsReal::getDirectChildrenWithNull());
8673 ret.push_back((const MEDFileAnyTypeFieldMultiTSWithoutSDA *)_content);
8678 * This method returns as MEDFileAnyTypeFieldMultiTS new instances as number of components in \a this.
8679 * The returned instances are deep copy of \a this except that for globals that are share with those contained in \a this.
8680 * ** WARNING ** do no forget to rename the ouput instances to avoid to write n-times in the same MED file field !
8682 std::vector< MCAuto< MEDFileAnyTypeFieldMultiTS > > MEDFileAnyTypeFieldMultiTS::splitComponents() const
8684 const MEDFileAnyTypeFieldMultiTSWithoutSDA *content(_content);
8686 throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::splitComponents : no content in this ! Unable to split components !");
8687 std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> > contentsSplit=content->splitComponents();
8688 std::size_t sz(contentsSplit.size());
8689 std::vector< MCAuto< MEDFileAnyTypeFieldMultiTS > > ret(sz);
8690 for(std::size_t i=0;i<sz;i++)
8692 ret[i]=shallowCpy();
8693 ret[i]->_content=contentsSplit[i];
8699 * This method returns as MEDFileAnyTypeFieldMultiTS new instances as number of discretizations over time steps in \a this.
8700 * The returned instances are shallow copied of \a this included globals that are share with those contained in \a this.
8702 std::vector< MCAuto< MEDFileAnyTypeFieldMultiTS > > MEDFileAnyTypeFieldMultiTS::splitDiscretizations() const
8704 const MEDFileAnyTypeFieldMultiTSWithoutSDA *content(_content);
8706 throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::splitDiscretizations : no content in this ! Unable to split discretizations !");
8707 std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> > contentsSplit(content->splitDiscretizations());
8708 std::size_t sz(contentsSplit.size());
8709 std::vector< MCAuto< MEDFileAnyTypeFieldMultiTS > > ret(sz);
8710 for(std::size_t i=0;i<sz;i++)
8712 ret[i]=shallowCpy();
8713 ret[i]->_content=contentsSplit[i];
8719 * This method returns as MEDFileAnyTypeFieldMultiTS new instances as number of sub-discretizations over time steps in \a this.
8720 * The returned instances are shallow copied of \a this included globals that are share with those contained in \a this.
8722 std::vector< MCAuto< MEDFileAnyTypeFieldMultiTS > > MEDFileAnyTypeFieldMultiTS::splitMultiDiscrPerGeoTypes() const
8724 const MEDFileAnyTypeFieldMultiTSWithoutSDA *content(_content);
8726 throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::splitMultiDiscrPerGeoTypes : no content in this ! Unable to split discretizations !");
8727 std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> > contentsSplit(content->splitMultiDiscrPerGeoTypes());
8728 std::size_t sz(contentsSplit.size());
8729 std::vector< MCAuto< MEDFileAnyTypeFieldMultiTS > > ret(sz);
8730 for(std::size_t i=0;i<sz;i++)
8732 ret[i]=shallowCpy();
8733 ret[i]->_content=contentsSplit[i];
8738 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::deepCopy() const
8740 MCAuto<MEDFileAnyTypeFieldMultiTS> ret=shallowCpy();
8741 if((const MEDFileAnyTypeFieldMultiTSWithoutSDA *)_content)
8742 ret->_content=_content->deepCopy();
8743 ret->deepCpyGlobs(*this);
8747 MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> MEDFileAnyTypeFieldMultiTS::getContent()
8753 * Returns a new MEDFileField1TS or MEDFileIntField1TS holding data of a given time step of \a this field.
8754 * \param [in] iteration - the iteration number of a required time step.
8755 * \param [in] order - the iteration order number of required time step.
8756 * \return MEDFileField1TS * or MEDFileIntField1TS *- a new instance of MEDFileField1TS or MEDFileIntField1TS. The caller is to
8757 * delete this field using decrRef() as it is no more needed.
8758 * \throw If there is no required time step in \a this field.
8760 MEDFileAnyTypeField1TS *MEDFileAnyTypeFieldMultiTS::getTimeStep(int iteration, int order) const
8762 int pos=getPosOfTimeStep(iteration,order);
8763 return getTimeStepAtPos(pos);
8767 * Returns a new MEDFileField1TS or MEDFileIntField1TS holding data of a given time step of \a this field.
8768 * \param [in] time - the time of the time step of interest.
8769 * \param [in] eps - a precision used to compare time values.
8770 * \return MEDFileField1TS * - a new instance of MEDFileField1TS. The caller is to
8771 * delete this field using decrRef() as it is no more needed.
8772 * \throw If there is no required time step in \a this field.
8774 MEDFileAnyTypeField1TS *MEDFileAnyTypeFieldMultiTS::getTimeStepGivenTime(double time, double eps) const
8776 int pos=getPosGivenTime(time,eps);
8777 return getTimeStepAtPos(pos);
8781 * This method groups not null items in \a vectFMTS per time step series. Two time series are considered equal if the list of their pair of integers iteration,order are equal.
8782 * The float64 value of time attached to the pair of integers are not considered here.
8783 * WARNING the returned pointers are not incremented. The caller is \b not responsible to deallocate them ! This method only reorganizes entries in \a vectFMTS.
8785 * \param [in] vectFMTS - vector of not null fields defined on a same global data pointer.
8786 * \throw If there is a null pointer in \a vectFMTS.
8788 std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > MEDFileAnyTypeFieldMultiTS::SplitIntoCommonTimeSeries(const std::vector<MEDFileAnyTypeFieldMultiTS *>& vectFMTS)
8790 static const char msg[]="MEDFileAnyTypeFieldMultiTS::SplitIntoCommonTimeSeries : presence of null instance in input vector !";
8791 std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > ret;
8792 std::list<MEDFileAnyTypeFieldMultiTS *> lstFMTS(vectFMTS.begin(),vectFMTS.end());
8793 while(!lstFMTS.empty())
8795 std::list<MEDFileAnyTypeFieldMultiTS *>::iterator it(lstFMTS.begin());
8796 MEDFileAnyTypeFieldMultiTS *curIt(*it);
8798 throw INTERP_KERNEL::Exception(msg);
8799 std::vector< std::pair<int,int> > refIts=curIt->getIterations();
8800 std::vector<MEDFileAnyTypeFieldMultiTS *> elt;
8801 elt.push_back(curIt); it=lstFMTS.erase(it);
8802 while(it!=lstFMTS.end())
8806 throw INTERP_KERNEL::Exception(msg);
8807 std::vector< std::pair<int,int> > curIts=curIt->getIterations();
8809 { elt.push_back(curIt); it=lstFMTS.erase(it); }
8819 * This method splits the input list \a vectFMTS considering the aspect of the geometrical support over time.
8820 * All returned instances in a subvector can be safely loaded, rendered along time
8821 * All items must be defined on the same time step ids ( see MEDFileAnyTypeFieldMultiTS::SplitIntoCommonTimeSeries method ).
8822 * Each item in \a vectFMTS is expected to have one and exactly one spatial discretization along time.
8823 * All items in \a vectFMTS must lie on the mesh (located by meshname and time step) and compatible with the input mesh \a mesh (having the same name than those in items).
8824 * All items in \a vectFMTS whose spatial discretization is not ON_NODES will appear once.
8825 * For items in \a vectFMTS that are ON_NODES it is possible to appear several times (more than once or once) in the returned vector.
8827 * \param [in] vectFMTS - list of multi times step part all defined each on a same spatial discretization along time and pointing to a mesh whose name is equal to \c mesh->getName().
8828 * \param [in] mesh - the mesh shared by all items in \a vectFMTS across time.
8829 * \param [out] fsc - A vector having same size than returned vector. It specifies the support comporator of the corresponding vector of MEDFileAnyTypeFieldMultiTS in returned vector of vector.
8830 * \return - A vector of vector of objects that contains the same pointers (objects) than thoose in \a vectFMTS except that there are organized differently. So pointers included in returned vector of vector should \b not been dealt by the caller.
8832 * \throw If an element in \a vectFMTS has not only one spatial discretization set.
8833 * \throw If an element in \a vectFMTS change of spatial discretization along time.
8834 * \throw If an element in \a vectFMTS lies on a mesh with meshname different from those in \a mesh.
8835 * \thorw If some elements in \a vectFMTS do not have the same times steps.
8836 * \throw If mesh is null.
8837 * \throw If an element in \a vectFMTS is null.
8838 * \sa MEDFileAnyTypeFieldMultiTS::AreOnSameSupportAcrossTime
8840 std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > MEDFileAnyTypeFieldMultiTS::SplitPerCommonSupport(const std::vector<MEDFileAnyTypeFieldMultiTS *>& vectFMTS, const MEDFileMesh *mesh, std::vector< MCAuto<MEDFileFastCellSupportComparator> >& fsc)
8842 static const char msg[]="MEDFileAnyTypeFieldMultiTS::SplitPerCommonSupport : presence of a null instance in the input vector !";
8844 throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::SplitPerCommonSupport : input mesh is null !");
8845 std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > ret;
8846 if(vectFMTS.empty())
8848 std::vector<MEDFileAnyTypeFieldMultiTS *>::const_iterator it(vectFMTS.begin());
8849 MEDFileAnyTypeFieldMultiTS *frstElt(*it);
8851 throw INTERP_KERNEL::Exception(msg);
8853 std::vector<MEDFileAnyTypeFieldMultiTS *> vectFMTSNotNodes;
8854 std::vector<MEDFileAnyTypeFieldMultiTS *> vectFMTSNodes;
8855 for(;it!=vectFMTS.end();it++,i++)
8858 throw INTERP_KERNEL::Exception(msg);
8859 TypeOfField tof0,tof1;
8860 if(CheckSupportAcrossTime(frstElt,*it,mesh,tof0,tof1)>0)
8863 vectFMTSNotNodes.push_back(*it);
8865 vectFMTSNodes.push_back(*it);
8868 vectFMTSNotNodes.push_back(*it);
8870 std::vector< MCAuto<MEDFileFastCellSupportComparator> > cmps;
8871 std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > retCell=SplitPerCommonSupportNotNodesAlg(vectFMTSNotNodes,mesh,cmps);
8873 for(std::vector<MEDFileAnyTypeFieldMultiTS *>::const_iterator it2=vectFMTSNodes.begin();it2!=vectFMTSNodes.end();it2++)
8876 bool isFetched(false);
8877 for(std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> >::const_iterator it0=retCell.begin();it0!=retCell.end();it0++,i++)
8880 throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::SplitPerCommonSupport : internal error !");
8881 if(cmps[i]->isCompatibleWithNodesDiscr(*it2))
8882 { ret[i].push_back(*it2); isFetched=true; }
8886 std::vector<MEDFileAnyTypeFieldMultiTS *> tmp(1,*it2);
8887 MCAuto<MEDFileMeshStruct> tmp2(MEDFileMeshStruct::New(mesh));
8888 ret.push_back(tmp); retCell.push_back(tmp); cmps.push_back(MEDFileFastCellSupportComparator::New(tmp2,*it2));
8896 * WARNING no check here. The caller must be sure that all items in vectFMTS are coherent each other in time steps, only one same spatial discretization and not ON_NODES.
8897 * \param [out] cmps - same size than the returned vector.
8899 std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > MEDFileAnyTypeFieldMultiTS::SplitPerCommonSupportNotNodesAlg(const std::vector<MEDFileAnyTypeFieldMultiTS *>& vectFMTS, const MEDFileMesh *mesh, std::vector< MCAuto<MEDFileFastCellSupportComparator> >& cmps)
8901 std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > ret;
8902 std::list<MEDFileAnyTypeFieldMultiTS *> lstFMTS(vectFMTS.begin(),vectFMTS.end());
8903 while(!lstFMTS.empty())
8905 std::list<MEDFileAnyTypeFieldMultiTS *>::iterator it(lstFMTS.begin());
8906 MEDFileAnyTypeFieldMultiTS *ref(*it);
8907 std::vector<MEDFileAnyTypeFieldMultiTS *> elt;
8908 elt.push_back(ref); it=lstFMTS.erase(it);
8909 MCAuto<MEDFileMeshStruct> mst(MEDFileMeshStruct::New(mesh));
8910 MCAuto<MEDFileFastCellSupportComparator> cmp(MEDFileFastCellSupportComparator::New(mst,ref));
8911 while(it!=lstFMTS.end())
8913 MEDFileAnyTypeFieldMultiTS *curIt(*it);
8914 if(cmp->isEqual(curIt))
8915 { elt.push_back(curIt); it=lstFMTS.erase(it); }
8919 ret.push_back(elt); cmps.push_back(cmp);
8925 * This method scan the two main structs along time of \a f0 and \a f1 to see if there are all lying on the same mesh along time than those in \a mesh.
8926 * \a f0 and \a f1 must be defined each only on a same spatial discretization even if this can be different each other.
8928 * \throw If \a f0 or \a f1 has not only one spatial discretization set.
8929 * \throw If \a f0 or \a f1 change of spatial discretization along time.
8930 * \throw If \a f0 or \a f1 on a mesh with meshname different from those in \a mesh.
8931 * \thorw If \a f0 and \a f1 do not have the same times steps.
8932 * \throw If mesh is null.
8933 * \throw If \a f0 or \a f1 is null.
8934 * \sa MEDFileAnyTypeFieldMultiTS::SplitPerCommonSupport
8936 int MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime(MEDFileAnyTypeFieldMultiTS *f0, MEDFileAnyTypeFieldMultiTS *f1, const MEDFileMesh *mesh, TypeOfField& tof0, TypeOfField& tof1)
8939 throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : input mesh is null !");
8941 throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : presence of null instance in fields over time !");
8942 if(f0->getMeshName()!=mesh->getName())
8944 std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : first field points to mesh \""<< f0->getMeshName() << "\" and input mesh to compare has name \"" << mesh->getName() << "\" !";
8945 throw INTERP_KERNEL::Exception(oss.str());
8947 if(f1->getMeshName()!=mesh->getName())
8949 std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : second field points to mesh \""<< f1->getMeshName() << "\" and input mesh to compare has name \"" << mesh->getName() << "\" !";
8950 throw INTERP_KERNEL::Exception(oss.str());
8952 int nts=f0->getNumberOfTS();
8953 if(nts!=f1->getNumberOfTS())
8954 throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : number of time steps are not the same !");
8957 for(int i=0;i<nts;i++)
8959 MCAuto<MEDFileAnyTypeField1TS> f0cur=f0->getTimeStepAtPos(i);
8960 MCAuto<MEDFileAnyTypeField1TS> f1cur=f1->getTimeStepAtPos(i);
8961 std::vector<TypeOfField> tofs0(f0cur->getTypesOfFieldAvailable()),tofs1(f1cur->getTypesOfFieldAvailable());
8962 if(tofs0.size()!=1 || tofs1.size()!=1)
8963 throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : All time steps must be defined on only one spatial discretization !");
8966 if(tof0!=tofs0[0] || tof1!=tofs1[0])
8967 throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : Across times steps MEDFileAnyTypeFieldMultiTS instances have to keep the same unique spatial discretization !");
8970 { tof0=tofs0[0]; tof1=tofs1[0]; }
8971 if(f0cur->getMeshIteration()!=mesh->getIteration() || f0cur->getMeshOrder()!=mesh->getOrder())
8973 std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : first field points to mesh time step (" << f0cur->getMeshIteration() << ","<< f0cur->getMeshOrder() << ") whereas input mesh points to time step (" << mesh->getIteration() << "," << mesh->getOrder() << ") !";
8974 throw INTERP_KERNEL::Exception(oss.str());
8976 if(f1cur->getMeshIteration()!=mesh->getIteration() || f1cur->getMeshOrder()!=mesh->getOrder())
8978 std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : second field points to mesh time step (" << f1cur->getMeshIteration() << ","<< f1cur->getMeshOrder() << ") whereas input mesh points to time step (" << mesh->getIteration() << "," << mesh->getOrder() << ") !";
8979 throw INTERP_KERNEL::Exception(oss.str());
8981 if(f0cur->getIteration()!=f1cur->getIteration() || f0cur->getOrder()!=f1cur->getOrder())
8983 std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : all the time steps must be the same ! it is not the case (" << f0cur->getIteration() << "," << f0cur->getOrder() << ")!=(" << f1cur->getIteration() << "," << f1cur->getOrder() << ") !";
8984 throw INTERP_KERNEL::Exception(oss.str());
8991 * Return an extraction of \a this using \a extractDef map to specify the extraction.
8992 * The keys of \a extractDef is level relative to max ext of \a mm mesh.
8994 * \return A new object that the caller is responsible to deallocate.
8996 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::extractPart(const std::map<int, MCAuto<DataArrayInt> >& extractDef, MEDFileMesh *mm) const
8999 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::extractPart : mesh is null !");
9000 MCAuto<MEDFileAnyTypeFieldMultiTS> fmtsOut(buildNewEmpty());
9001 int nbTS(getNumberOfTS());
9002 for(int i=0;i<nbTS;i++)
9004 MCAuto<MEDFileAnyTypeField1TS> f1ts(getTimeStepAtPos(i));
9005 MCAuto<MEDFileAnyTypeField1TS> f1tsOut(f1ts->extractPart(extractDef,mm));
9006 fmtsOut->pushBackTimeStep(f1tsOut);
9008 return fmtsOut.retn();
9012 MCAuto<MEDFileAnyTypeField1TS> AggregateHelperF1TS(const std::vector< typename MLFieldTraits<T>::F1TSType const *>& f1tss, const std::vector< std::vector< std::pair<int,int> > >& dts)
9014 MCAuto< typename MLFieldTraits<T>::F1TSType > ret(MLFieldTraits<T>::F1TSType::New());
9016 throw INTERP_KERNEL::Exception("AggregateHelperF1TS : empty vector !");
9017 std::size_t sz(f1tss.size()),i(0);
9018 std::vector< typename MLFieldTraits<T>::F1TSWSDAType const *> f1tsw(sz);
9019 for(typename std::vector< typename MLFieldTraits<T>::F1TSType const *>::const_iterator it=f1tss.begin();it!=f1tss.end();it++,i++)
9021 typename MLFieldTraits<T>::F1TSType const *elt(*it);
9023 throw INTERP_KERNEL::Exception("AggregateHelperF1TS : presence of a null pointer !");
9024 f1tsw[i]=dynamic_cast<typename MLFieldTraits<T>::F1TSWSDAType const *>(elt->contentNotNullBase());
9026 typename MLFieldTraits<T>::F1TSWSDAType *retc(dynamic_cast<typename MLFieldTraits<T>::F1TSWSDAType *>(ret->contentNotNullBase()));
9028 throw INTERP_KERNEL::Exception("AggregateHelperF1TS : internal error 1 !");
9029 retc->aggregate(f1tsw,dts);
9030 ret->setDtUnit(f1tss[0]->getDtUnit());
9031 return DynamicCast<typename MLFieldTraits<T>::F1TSType , MEDFileAnyTypeField1TS>(ret);
9035 MCAuto< MEDFileAnyTypeFieldMultiTS > AggregateHelperFMTS(const std::vector< typename MLFieldTraits<T>::FMTSType const *>& fmtss, const std::vector< std::vector< std::pair<int,int> > >& dts)
9037 MCAuto< typename MLFieldTraits<T>::FMTSType > ret(MLFieldTraits<T>::FMTSType::New());
9039 throw INTERP_KERNEL::Exception("AggregateHelperFMTS : empty vector !");
9040 std::size_t sz(fmtss.size());
9041 for(typename std::vector< typename MLFieldTraits<T>::FMTSType const *>::const_iterator it=fmtss.begin();it!=fmtss.end();it++)
9043 typename MLFieldTraits<T>::FMTSType const *elt(*it);
9045 throw INTERP_KERNEL::Exception("AggregateHelperFMTS : presence of null pointer !");
9047 int nbTS(fmtss[0]->getNumberOfTS());
9048 for(typename std::vector< typename MLFieldTraits<T>::FMTSType const *>::const_iterator it=fmtss.begin();it!=fmtss.end();it++)
9049 if((*it)->getNumberOfTS()!=nbTS)
9050 throw INTERP_KERNEL::Exception("AggregateHelperFMTS : all fields must have the same number of TS !");
9051 for(int iterTS=0;iterTS<nbTS;iterTS++)
9054 std::vector< typename MLFieldTraits<T>::F1TSType const *> f1tss(sz);
9055 std::vector< MCAuto<typename MLFieldTraits<T>::F1TSType> > f1tss2(sz);
9056 for(typename std::vector< typename MLFieldTraits<T>::FMTSType const *>::const_iterator it=fmtss.begin();it!=fmtss.end();it++,i++)
9057 { f1tss2[i]=(*it)->getTimeStepAtPos(iterTS); f1tss[i]=f1tss2[i]; }
9058 MCAuto<MEDFileAnyTypeField1TS> f1ts(AggregateHelperF1TS<T>(f1tss,dts));
9059 ret->pushBackTimeStep(f1ts);
9060 ret->setDtUnit(f1ts->getDtUnit());
9062 return DynamicCast<typename MLFieldTraits<T>::FMTSType , MEDFileAnyTypeFieldMultiTS>(ret);
9066 * \a dts and \a ftmss are expected to have same size.
9068 MCAuto<MEDFileAnyTypeFieldMultiTS> MEDFileAnyTypeFieldMultiTS::Aggregate(const std::vector<const MEDFileAnyTypeFieldMultiTS *>& fmtss, const std::vector< std::vector< std::pair<int,int> > >& dts)
9071 throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::Aggregate : input vector is empty !");
9072 std::size_t sz(fmtss.size());
9073 std::vector<const MEDFileFieldMultiTS *> fmtss1;
9074 std::vector<const MEDFileIntFieldMultiTS *> fmtss2;
9075 for(std::vector<const MEDFileAnyTypeFieldMultiTS *>::const_iterator it=fmtss.begin();it!=fmtss.end();it++)
9078 throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::Aggregate : presence of null instance in input vector !");
9079 const MEDFileFieldMultiTS *elt1(dynamic_cast<const MEDFileFieldMultiTS *>(*it));
9082 fmtss1.push_back(elt1);
9085 const MEDFileIntFieldMultiTS *elt2(dynamic_cast<const MEDFileIntFieldMultiTS *>(*it));
9088 fmtss2.push_back(elt2);
9091 throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::Aggregate : not recognized type !");
9093 if(fmtss1.size()!=sz && fmtss2.size()!=sz)
9094 throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::Aggregate : type of data is not homogeneous !");
9095 if(fmtss1.size()==sz)
9096 return AggregateHelperFMTS<double>(fmtss1,dts);
9097 if(fmtss2.size()!=sz)
9098 return AggregateHelperFMTS<int>(fmtss2,dts);
9099 throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::Aggregate : not implemented yet !");
9102 MEDFileAnyTypeFieldMultiTSIterator *MEDFileAnyTypeFieldMultiTS::iterator()
9104 return new MEDFileAnyTypeFieldMultiTSIterator(this);
9107 //= MEDFileFieldMultiTS
9110 * Returns a new empty instance of MEDFileFieldMultiTS.
9111 * \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS. The caller
9112 * is to delete this field using decrRef() as it is no more needed.
9114 MEDFileFieldMultiTS *MEDFileFieldMultiTS::New()
9116 return new MEDFileFieldMultiTS;
9120 * Returns a new instance of MEDFileFieldMultiTS holding data of the first field
9121 * that has been read from a specified MED file.
9122 * \param [in] fileName - the name of the MED file to read.
9123 * \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS. The caller
9124 * is to delete this field using decrRef() as it is no more needed.
9125 * \throw If reading the file fails.
9127 MEDFileFieldMultiTS *MEDFileFieldMultiTS::New(const std::string& fileName, bool loadAll)
9129 MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
9130 MCAuto<MEDFileFieldMultiTS> ret(new MEDFileFieldMultiTS(fid,loadAll,0));
9131 ret->contentNotNull();//to check that content type matches with \a this type.
9136 * Returns a new instance of MEDFileFieldMultiTS holding data of a given field
9137 * that has been read from a specified MED file.
9138 * \param [in] fileName - the name of the MED file to read.
9139 * \param [in] fieldName - the name of the field to read.
9140 * \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS. The caller
9141 * is to delete this field using decrRef() as it is no more needed.
9142 * \throw If reading the file fails.
9143 * \throw If there is no field named \a fieldName in the file.
9145 MEDFileFieldMultiTS *MEDFileFieldMultiTS::New(const std::string& fileName, const std::string& fieldName, bool loadAll)
9147 MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
9148 MCAuto<MEDFileFieldMultiTS> ret(new MEDFileFieldMultiTS(fid,fieldName,loadAll,0));
9149 ret->contentNotNull();//to check that content type matches with \a this type.
9154 * Returns a new instance of MEDFileFieldMultiTS. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
9155 * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
9157 * Returns a new instance of MEDFileFieldMultiTS holding either a shallow copy
9158 * of a given MEDFileFieldMultiTSWithoutSDA ( \a other ) or \a other itself.
9159 * \warning this is a shallow copy constructor
9160 * \param [in] other - a MEDFileField1TSWithoutSDA to copy.
9161 * \param [in] shallowCopyOfContent - if \c true, a shallow copy of \a other is created.
9162 * \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS. The caller
9163 * is to delete this field using decrRef() as it is no more needed.
9165 MEDFileFieldMultiTS *MEDFileFieldMultiTS::New(const MEDFileFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent)
9167 return new MEDFileFieldMultiTS(other,shallowCopyOfContent);
9170 MEDFileFieldMultiTS *MEDFileFieldMultiTS::LoadSpecificEntities(const std::string& fileName, const std::string& fieldName, const std::vector< std::pair<TypeOfField,INTERP_KERNEL::NormalizedCellType> >& entities, bool loadAll)
9172 MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
9173 MCAuto<MEDFileFieldMultiTS> ret(new MEDFileFieldMultiTS(fid,fieldName,loadAll,0,&entities));
9174 ret->contentNotNull();//to check that content type matches with \a this type.
9178 MEDFileAnyTypeFieldMultiTS *MEDFileFieldMultiTS::shallowCpy() const
9180 return new MEDFileFieldMultiTS(*this);
9183 void MEDFileFieldMultiTS::checkCoherencyOfType(const MEDFileAnyTypeField1TS *f1ts) const
9186 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::checkCoherencyOfType : input field1TS is NULL ! Impossible to check !");
9187 const MEDFileField1TS *f1tsC=dynamic_cast<const MEDFileField1TS *>(f1ts);
9189 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::checkCoherencyOfType : the input field1TS is not a FLOAT64 type !");
9193 * This method performs a copy with datatype modification ( float64->int32 ) of \a this. The globals information are copied
9194 * following the given input policy.
9196 * \param [in] isDeepCpyGlobs - a boolean that indicates the behaviour concerning globals (profiles and localizations)
9197 * By default (true) the globals are deeply copied.
9198 * \return MEDFileIntFieldMultiTS * - a new object that is the result of the conversion of \a this to int32 field.
9200 MEDFileIntFieldMultiTS *MEDFileFieldMultiTS::convertToInt(bool isDeepCpyGlobs) const
9202 MCAuto<MEDFileIntFieldMultiTS> ret;
9203 const MEDFileAnyTypeFieldMultiTSWithoutSDA *content(_content);
9206 const MEDFileFieldMultiTSWithoutSDA *contc=dynamic_cast<const MEDFileFieldMultiTSWithoutSDA *>(content);
9208 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::convertToInt : the content inside this is not FLOAT64 ! This is incoherent !");
9209 MCAuto<MEDFileIntFieldMultiTSWithoutSDA> newc(contc->convertToInt());
9210 ret=static_cast<MEDFileIntFieldMultiTS *>(MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent((MEDFileIntFieldMultiTSWithoutSDA *)newc,getFileName()));
9213 ret=MEDFileIntFieldMultiTS::New();
9215 ret->deepCpyGlobs(*this);
9217 ret->shallowCpyGlobs(*this);
9222 * Returns a new MEDFileField1TS holding data of a given time step of \a this field.
9223 * \param [in] pos - a time step id.
9224 * \return MEDFileField1TS * - a new instance of MEDFileField1TS. The caller is to
9225 * delete this field using decrRef() as it is no more needed.
9226 * \throw If \a pos is not a valid time step id.
9228 MEDFileField1TS *MEDFileFieldMultiTS::getTimeStepAtPos(int pos) const
9230 const MEDFileAnyTypeField1TSWithoutSDA *item=contentNotNullBase()->getTimeStepAtPos2(pos);
9233 std::ostringstream oss; oss << "MEDFileFieldMultiTS::getTimeStepAtPos : field at pos #" << pos << " is null !";
9234 throw INTERP_KERNEL::Exception(oss.str());
9236 const MEDFileField1TSWithoutSDA *itemC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(item);
9239 MCAuto<MEDFileField1TS> ret=MEDFileField1TS::New(*itemC,false);
9240 ret->shallowCpyGlobs(*this);
9243 std::ostringstream oss; oss << "MEDFileFieldMultiTS::getTimeStepAtPos : type of field at pos #" << pos << " is not FLOAT64 !";
9244 throw INTERP_KERNEL::Exception(oss.str());
9248 * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
9249 * mesh entities of a given dimension of the first mesh in MED file.
9250 * For more info, see \ref AdvMEDLoaderAPIFieldRW
9251 * \param [in] type - a spatial discretization of interest.
9252 * \param [in] iteration - the iteration number of a required time step.
9253 * \param [in] order - the iteration order number of required time step.
9254 * \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
9255 * \param [in] renumPol - specifies how to permute values of the result field according to
9256 * the optional numbers of cells and nodes, if any. The valid values are
9257 * - 0 - do not permute.
9258 * - 1 - permute cells.
9259 * - 2 - permute nodes.
9260 * - 3 - permute cells and nodes.
9262 * \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
9263 * caller is to delete this field using decrRef() as it is no more needed.
9264 * \throw If the MED file is not readable.
9265 * \throw If there is no mesh in the MED file.
9266 * \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
9267 * \throw If no field values of the required parameters are available.
9269 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldAtLevel(TypeOfField type, int iteration, int order, int meshDimRelToMax, int renumPol) const
9271 const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
9272 const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
9274 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldAtLevel : mismatch of type of field expecting FLOAT64 !");
9275 MCAuto<DataArray> arrOut;
9276 MCAuto<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtLevel(type,meshDimRelToMax,std::string(),renumPol,this,arrOut,*contentNotNullBase());
9277 MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
9282 * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
9283 * the top level cells of the first mesh in MED file.
9284 * For more info, see \ref AdvMEDLoaderAPIFieldRW
9285 * \param [in] type - a spatial discretization of interest.
9286 * \param [in] iteration - the iteration number of a required time step.
9287 * \param [in] order - the iteration order number of required time step.
9288 * \param [in] renumPol - specifies how to permute values of the result field according to
9289 * the optional numbers of cells and nodes, if any. The valid values are
9290 * - 0 - do not permute.
9291 * - 1 - permute cells.
9292 * - 2 - permute nodes.
9293 * - 3 - permute cells and nodes.
9295 * \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
9296 * caller is to delete this field using decrRef() as it is no more needed.
9297 * \throw If the MED file is not readable.
9298 * \throw If there is no mesh in the MED file.
9299 * \throw If no field values of the required parameters are available.
9301 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldAtTopLevel(TypeOfField type, int iteration, int order, int renumPol) const
9303 const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
9304 const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
9306 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldAtTopLevel : mismatch of type of field !");
9307 MCAuto<DataArray> arrOut;
9308 MCAuto<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtTopLevel(type,std::string(),renumPol,this,arrOut,*contentNotNullBase());
9309 MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
9314 * This is the simplest version to fetch a field for MED structure. One drawback : if \a this is a complex field (multi spatial discretization inside a same field) this method will throw exception and more advance
9315 * method should be called (getFieldOnMeshAtLevel for example).
9316 * But for normal usage of field in MED file world this method is the most efficient to fetch data.
9318 * \param [in] iteration - the iteration number of a required time step.
9319 * \param [in] order - the iteration order number of required time step.
9320 * \param [in] mesh - the mesh the field is lying on
9321 * \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
9322 * caller is to delete this field using decrRef() as it is no more needed.
9324 MEDCouplingFieldDouble *MEDFileFieldMultiTS::field(int iteration, int order, const MEDFileMesh *mesh) const
9326 const MEDFileAnyTypeField1TSWithoutSDA& myF1TS(contentNotNullBase()->getTimeStepEntry(iteration,order));
9327 MCAuto<DataArray> arrOut;
9328 MCAuto<MEDCouplingFieldDouble> ret(myF1TS.fieldOnMesh(this,mesh,arrOut,*contentNotNullBase()));
9329 MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
9334 * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
9336 * For more info, see \ref AdvMEDLoaderAPIFieldRW
9337 * \param [in] type - a spatial discretization of interest.
9338 * \param [in] iteration - the iteration number of a required time step.
9339 * \param [in] order - the iteration order number of required time step.
9340 * \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
9341 * \param [in] mesh - the supporting mesh.
9342 * \param [in] renumPol - specifies how to permute values of the result field according to
9343 * the optional numbers of cells and nodes, if any. The valid values are
9344 * - 0 - do not permute.
9345 * - 1 - permute cells.
9346 * - 2 - permute nodes.
9347 * - 3 - permute cells and nodes.
9349 * \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
9350 * caller is to delete this field using decrRef() as it is no more needed.
9351 * \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
9352 * \throw If no field of \a this is lying on \a mesh.
9353 * \throw If no field values of the required parameters are available.
9355 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldOnMeshAtLevel(TypeOfField type, int iteration, int order, int meshDimRelToMax, const MEDFileMesh *mesh, int renumPol) const
9357 const MEDFileAnyTypeField1TSWithoutSDA& myF1TS(contentNotNullBase()->getTimeStepEntry(iteration,order));
9358 const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
9360 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldOnMeshAtLevel : mismatch of type of field !");
9361 MCAuto<DataArray> arrOut;
9362 MCAuto<MEDCouplingFieldDouble> ret=myF1TSC->getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,this,mesh,arrOut,*contentNotNullBase());
9363 MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
9368 * Returns a new MEDCouplingFieldDouble of given type, of a given time step, lying on a
9370 * For more info, see \ref AdvMEDLoaderAPIFieldRW
9371 * \param [in] type - a spatial discretization of the new field.
9372 * \param [in] iteration - the iteration number of a required time step.
9373 * \param [in] order - the iteration order number of required time step.
9374 * \param [in] mesh - the supporting mesh.
9375 * \param [in] renumPol - specifies how to permute values of the result field according to
9376 * the optional numbers of cells and nodes, if any. The valid values are
9377 * - 0 - do not permute.
9378 * - 1 - permute cells.
9379 * - 2 - permute nodes.
9380 * - 3 - permute cells and nodes.
9382 * \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
9383 * caller is to delete this field using decrRef() as it is no more needed.
9384 * \throw If no field of \a this is lying on \a mesh.
9385 * \throw If no field values of the required parameters are available.
9387 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldOnMeshAtLevel(TypeOfField type, int iteration, int order, const MEDCouplingMesh *mesh, int renumPol) const
9389 const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
9390 const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
9392 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldOnMeshAtLevel : mismatch of type of field !");
9393 MCAuto<DataArray> arrOut;
9394 MCAuto<MEDCouplingFieldDouble> ret=myF1TSC->getFieldOnMeshAtLevel(type,renumPol,this,mesh,0,0,arrOut,*contentNotNullBase());
9395 MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
9400 * This method has a close behaviour than MEDFileFieldMultiTS::getFieldAtLevel.
9401 * This method is called 'old' because the user should give the mesh name he wants to use for it's field.
9402 * This method is useful for MED2 file format when field on different mesh was autorized.
9404 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldAtLevelOld(TypeOfField type, const std::string& mname, int iteration, int order, int meshDimRelToMax, int renumPol) const
9406 const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
9407 const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
9409 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldAtLevelOld : mismatch of type of field !");
9410 MCAuto<DataArray> arrOut;
9411 MCAuto<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtLevel(type,meshDimRelToMax,mname,renumPol,this,arrOut,*contentNotNullBase());
9412 MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
9417 * Returns values and a profile of the field of a given type, of a given time step,
9418 * lying on a given support.
9419 * For more info, see \ref AdvMEDLoaderAPIFieldRW
9420 * \param [in] type - a spatial discretization of the field.
9421 * \param [in] iteration - the iteration number of a required time step.
9422 * \param [in] order - the iteration order number of required time step.
9423 * \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
9424 * \param [in] mesh - the supporting mesh.
9425 * \param [out] pfl - a new instance of DataArrayInt holding ids of mesh entities the
9426 * field of interest lies on. If the field lies on all entities of the given
9427 * dimension, all ids in \a pfl are zero. The caller is to delete this array
9428 * using decrRef() as it is no more needed.
9429 * \param [in] glob - the global data storing profiles and localization.
9430 * \return DataArrayDouble * - a new instance of DataArrayDouble holding values of the
9431 * field. The caller is to delete this array using decrRef() as it is no more needed.
9432 * \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
9433 * \throw If no field of \a this is lying on \a mesh.
9434 * \throw If no field values of the required parameters are available.
9436 DataArrayDouble *MEDFileFieldMultiTS::getFieldWithProfile(TypeOfField type, int iteration, int order, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt *&pfl) const
9438 const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
9439 const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
9441 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldWithProfile : mismatch of type of field !");
9442 MCAuto<DataArray> ret=myF1TSC->getFieldWithProfile(type,meshDimRelToMax,mesh,pfl,this,*contentNotNullBase());
9443 return MEDFileField1TS::ReturnSafelyDataArrayDouble(ret);
9446 const MEDFileFieldMultiTSWithoutSDA *MEDFileFieldMultiTS::contentNotNull() const
9448 const MEDFileAnyTypeFieldMultiTSWithoutSDA *pt(_content);
9450 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::contentNotNull : the content pointer is null !");
9451 const MEDFileFieldMultiTSWithoutSDA *ret=dynamic_cast<const MEDFileFieldMultiTSWithoutSDA *>(pt);
9453 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::contentNotNull : the content pointer is not null but it is not of type double ! Reason is maybe that the read field has not the type FLOAT64 !");
9457 MEDFileFieldMultiTSWithoutSDA *MEDFileFieldMultiTS::contentNotNull()
9459 MEDFileAnyTypeFieldMultiTSWithoutSDA *pt(_content);
9461 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::contentNotNull : the non const content pointer is null !");
9462 MEDFileFieldMultiTSWithoutSDA *ret=dynamic_cast<MEDFileFieldMultiTSWithoutSDA *>(pt);
9464 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::contentNotNull : the non const content pointer is not null but it is not of type double ! Reason is maybe that the read field has not the type FLOAT64 !");
9469 * Adds a MEDCouplingFieldDouble to \a this as another time step. The underlying mesh of
9470 * the given field is checked if its elements are sorted suitable for writing to MED file
9471 * ("STB" stands for "Sort By Type"), if not, an exception is thrown.
9472 * For more info, see \ref AdvMEDLoaderAPIFieldRW
9473 * \param [in] field - the field to add to \a this.
9474 * \throw If the name of \a field is empty.
9475 * \throw If the data array of \a field is not set.
9476 * \throw If existing time steps have different name or number of components than \a field.
9477 * \throw If the underlying mesh of \a field has no name.
9478 * \throw If elements in the mesh are not in the order suitable for writing to the MED file.
9480 void MEDFileFieldMultiTS::appendFieldNoProfileSBT(const MEDCouplingFieldDouble *field)
9482 const DataArrayDouble *arr=0;
9484 arr=field->getArray();
9485 contentNotNull()->appendFieldNoProfileSBT(field,arr,*this);
9489 * Adds a MEDCouplingFieldDouble to \a this as another time step.
9490 * The mesh support of input parameter \a field is ignored here, it can be NULL.
9491 * The support of field \a field is expected to be those computed with the input parameter \a mesh, \a meshDimRelToMax,
9494 * This method will check that the field based on the computed support is coherent. If not an exception will be thrown.
9495 * A new profile is added only if no equal profile is missing.
9496 * For more info, see \ref AdvMEDLoaderAPIFieldRW
9497 * \param [in] field - the field to add to \a this. The mesh support of field is ignored.
9498 * \param [in] mesh - the supporting mesh of \a field.
9499 * \param [in] meshDimRelToMax - a relative dimension of mesh entities \a field lies on (useless if field spatial discretization is ON_NODES).
9500 * \param [in] profile - ids of mesh entities on which corresponding field values lie.
9501 * \throw If either \a field or \a mesh or \a profile has an empty name.
9502 * \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
9503 * \throw If the data array of \a field is not set.
9504 * \throw If the data array of \a this is already allocated but has different number of
9505 * components than \a field.
9506 * \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
9507 * \sa setFieldNoProfileSBT()
9509 void MEDFileFieldMultiTS::appendFieldProfile(const MEDCouplingFieldDouble *field, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile)
9511 const DataArrayDouble *arr=0;
9513 arr=field->getArray();
9514 contentNotNull()->appendFieldProfile(field,arr,mesh,meshDimRelToMax,profile,*this);
9517 MEDFileFieldMultiTS::MEDFileFieldMultiTS()
9519 _content=new MEDFileFieldMultiTSWithoutSDA;
9522 MEDFileFieldMultiTS::MEDFileFieldMultiTS(med_idt fid, bool loadAll, const MEDFileMeshes *ms)
9523 try:MEDFileAnyTypeFieldMultiTS(fid,loadAll,ms)
9526 catch(INTERP_KERNEL::Exception& e)
9529 MEDFileFieldMultiTS::MEDFileFieldMultiTS(med_idt fid, const std::string& fieldName, bool loadAll, const MEDFileMeshes *ms, const std::vector< std::pair<TypeOfField,INTERP_KERNEL::NormalizedCellType> > *entities)
9530 try:MEDFileAnyTypeFieldMultiTS(fid,fieldName,loadAll,ms,entities)
9533 catch(INTERP_KERNEL::Exception& e)
9536 MEDFileFieldMultiTS::MEDFileFieldMultiTS(const MEDFileFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent):MEDFileAnyTypeFieldMultiTS(other,shallowCopyOfContent)
9540 std::vector< std::vector<DataArrayDouble *> > MEDFileFieldMultiTS::getFieldSplitedByType2(int iteration, int order, const std::string& 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
9542 return contentNotNull()->getFieldSplitedByType2(iteration,order,mname,types,typesF,pfls,locs);
9545 DataArrayDouble *MEDFileFieldMultiTS::getUndergroundDataArray(int iteration, int order) const
9547 return static_cast<DataArrayDouble *>(contentNotNull()->getUndergroundDataArray(iteration,order));
9550 DataArrayDouble *MEDFileFieldMultiTS::getUndergroundDataArrayExt(int iteration, int order, std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
9552 return static_cast<DataArrayDouble *>(contentNotNull()->getUndergroundDataArrayExt(iteration,order,entries));
9555 MEDFileFieldMultiTS *MEDFileFieldMultiTS::buildNewEmpty() const
9557 return MEDFileFieldMultiTS::New();
9560 //= MEDFileAnyTypeFieldMultiTSIterator
9562 MEDFileAnyTypeFieldMultiTSIterator::MEDFileAnyTypeFieldMultiTSIterator(MEDFileAnyTypeFieldMultiTS *fmts):_fmts(fmts),_iter_id(0),_nb_iter(0)
9567 _nb_iter=fmts->getNumberOfTS();
9571 MEDFileAnyTypeFieldMultiTSIterator::~MEDFileAnyTypeFieldMultiTSIterator()
9575 MEDFileAnyTypeField1TS *MEDFileAnyTypeFieldMultiTSIterator::nextt()
9577 if(_iter_id<_nb_iter)
9579 MEDFileAnyTypeFieldMultiTS *fmts(_fmts);
9581 return fmts->getTimeStepAtPos(_iter_id++);
9589 //= MEDFileIntFieldMultiTS
9592 * Returns a new empty instance of MEDFileFieldMultiTS.
9593 * \return MEDFileIntFieldMultiTS * - a new instance of MEDFileIntFieldMultiTS. The caller
9594 * is to delete this field using decrRef() as it is no more needed.
9596 MEDFileIntFieldMultiTS *MEDFileIntFieldMultiTS::New()
9598 return new MEDFileIntFieldMultiTS;
9602 * Returns a new instance of MEDFileIntFieldMultiTS holding data of the first field
9603 * that has been read from a specified MED file.
9604 * \param [in] fileName - the name of the MED file to read.
9605 * \return MEDFileFieldMultiTS * - a new instance of MEDFileIntFieldMultiTS. The caller
9606 * is to delete this field using decrRef() as it is no more needed.
9607 * \throw If reading the file fails.
9609 MEDFileIntFieldMultiTS *MEDFileIntFieldMultiTS::New(const std::string& fileName, bool loadAll)
9611 MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
9612 MCAuto<MEDFileIntFieldMultiTS> ret(new MEDFileIntFieldMultiTS(fid,loadAll,0));
9613 ret->contentNotNull();//to check that content type matches with \a this type.
9618 * Returns a new instance of MEDFileIntFieldMultiTS holding data of a given field
9619 * that has been read from a specified MED file.
9620 * \param [in] fileName - the name of the MED file to read.
9621 * \param [in] fieldName - the name of the field to read.
9622 * \return MEDFileFieldMultiTS * - a new instance of MEDFileIntFieldMultiTS. The caller
9623 * is to delete this field using decrRef() as it is no more needed.
9624 * \throw If reading the file fails.
9625 * \throw If there is no field named \a fieldName in the file.
9627 MEDFileIntFieldMultiTS *MEDFileIntFieldMultiTS::New(const std::string& fileName, const std::string& fieldName, bool loadAll)
9629 MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
9630 MCAuto<MEDFileIntFieldMultiTS> ret(new MEDFileIntFieldMultiTS(fid,fieldName,loadAll,0));
9631 ret->contentNotNull();//to check that content type matches with \a this type.
9636 * Returns a new instance of MEDFileIntFieldMultiTS. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
9637 * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
9639 * Returns a new instance of MEDFileIntFieldMultiTS holding either a shallow copy
9640 * of a given MEDFileIntFieldMultiTSWithoutSDA ( \a other ) or \a other itself.
9641 * \warning this is a shallow copy constructor
9642 * \param [in] other - a MEDFileIntField1TSWithoutSDA to copy.
9643 * \param [in] shallowCopyOfContent - if \c true, a shallow copy of \a other is created.
9644 * \return MEDFileIntFieldMultiTS * - a new instance of MEDFileIntFieldMultiTS. The caller
9645 * is to delete this field using decrRef() as it is no more needed.
9647 MEDFileIntFieldMultiTS *MEDFileIntFieldMultiTS::New(const MEDFileIntFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent)
9649 return new MEDFileIntFieldMultiTS(other,shallowCopyOfContent);
9652 MEDFileIntFieldMultiTS *MEDFileIntFieldMultiTS::LoadSpecificEntities(const std::string& fileName, const std::string& fieldName, const std::vector< std::pair<TypeOfField,INTERP_KERNEL::NormalizedCellType> >& entities, bool loadAll)
9654 MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
9655 MCAuto<MEDFileIntFieldMultiTS> ret(new MEDFileIntFieldMultiTS(fid,fieldName,loadAll,0,&entities));
9656 ret->contentNotNull();//to check that content type matches with \a this type.
9661 * This method performs a copy with datatype modification ( int32->float64 ) of \a this. The globals information are copied
9662 * following the given input policy.
9664 * \param [in] isDeepCpyGlobs - a boolean that indicates the behaviour concerning globals (profiles and localizations)
9665 * By default (true) the globals are deeply copied.
9666 * \return MEDFileFieldMultiTS * - a new object that is the result of the conversion of \a this to float64 field.
9668 MEDFileFieldMultiTS *MEDFileIntFieldMultiTS::convertToDouble(bool isDeepCpyGlobs) const
9670 MCAuto<MEDFileFieldMultiTS> ret;
9671 const MEDFileAnyTypeFieldMultiTSWithoutSDA *content(_content);
9674 const MEDFileIntFieldMultiTSWithoutSDA *contc=dynamic_cast<const MEDFileIntFieldMultiTSWithoutSDA *>(content);
9676 throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::convertToInt : the content inside this is not INT32 ! This is incoherent !");
9677 MCAuto<MEDFileFieldMultiTSWithoutSDA> newc(contc->convertToDouble());
9678 ret=static_cast<MEDFileFieldMultiTS *>(MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent((MEDFileFieldMultiTSWithoutSDA *)newc,getFileName()));
9681 ret=MEDFileFieldMultiTS::New();
9683 ret->deepCpyGlobs(*this);
9685 ret->shallowCpyGlobs(*this);
9689 MEDFileAnyTypeFieldMultiTS *MEDFileIntFieldMultiTS::shallowCpy() const
9691 return new MEDFileIntFieldMultiTS(*this);
9694 void MEDFileIntFieldMultiTS::checkCoherencyOfType(const MEDFileAnyTypeField1TS *f1ts) const
9697 throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::checkCoherencyOfType : input field1TS is NULL ! Impossible to check !");
9698 const MEDFileIntField1TS *f1tsC=dynamic_cast<const MEDFileIntField1TS *>(f1ts);
9700 throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::checkCoherencyOfType : the input field1TS is not a INT32 type !");
9704 * This is the simplest version to fetch a field for MED structure. One drawback : if \a this is a complex field (multi spatial discretization inside a same field) this method will throw exception and more advance
9705 * method should be called (getFieldOnMeshAtLevel for example).
9706 * But for normal usage of field in MED file world this method is the most efficient to fetch data.
9708 * \param [in] iteration - the iteration number of a required time step.
9709 * \param [in] order - the iteration order number of required time step.
9710 * \param [in] mesh - the mesh the field is lying on
9711 * \return MEDCouplingFieldInt * - a new instance of MEDCouplingFieldInt. The
9712 * caller is to delete this field using decrRef() as it is no more needed.
9714 MEDCouplingFieldInt *MEDFileIntFieldMultiTS::field(int iteration, int order, const MEDFileMesh *mesh) const
9716 const MEDFileAnyTypeField1TSWithoutSDA& myF1TS(contentNotNullBase()->getTimeStepEntry(iteration,order));
9717 const MEDFileIntField1TSWithoutSDA *myF1TSC(dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS));
9719 throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::field : mismatch of type of field expecting INT32 !");
9720 MCAuto<DataArray> arrOut;
9721 MCAuto<MEDCouplingFieldDouble> ret(myF1TS.fieldOnMesh(this,mesh,arrOut,*contentNotNullBase()));
9722 MCAuto<MEDCouplingFieldInt> ret2(MEDFileIntField1TS::SetDataArrayDoubleInIntField(ret,arrOut));
9727 * Returns a new MEDCouplingFieldInt of a given type, of a given time step, lying on
9728 * mesh entities of a given dimension of the first mesh in MED file.
9729 * For more info, see \ref AdvMEDLoaderAPIFieldRW
9730 * \param [in] type - a spatial discretization of interest.
9731 * \param [in] iteration - the iteration number of a required time step.
9732 * \param [in] order - the iteration order number of required time step.
9733 * \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
9734 * \param [in] renumPol - specifies how to permute values of the result field according to
9735 * the optional numbers of cells and nodes, if any. The valid values are
9736 * - 0 - do not permute.
9737 * - 1 - permute cells.
9738 * - 2 - permute nodes.
9739 * - 3 - permute cells and nodes.
9741 * \return MEDCouplingFieldInt * - a new instance of MEDCouplingFieldDouble. The
9742 * caller is to delete this field using decrRef() as it is no more needed.
9743 * \throw If the MED file is not readable.
9744 * \throw If there is no mesh in the MED file.
9745 * \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
9746 * \throw If no field values of the required parameters are available.
9748 MEDCouplingFieldInt *MEDFileIntFieldMultiTS::getFieldAtLevel(TypeOfField type, int iteration, int order, int meshDimRelToMax, int renumPol) const
9750 const MEDFileAnyTypeField1TSWithoutSDA& myF1TS(contentNotNullBase()->getTimeStepEntry(iteration,order));
9751 const MEDFileIntField1TSWithoutSDA *myF1TSC(dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS));
9753 throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::getFieldAtLevel : mismatch of type of field expecting INT32 !");
9754 MCAuto<DataArray> arr;
9755 MCAuto<MEDCouplingFieldDouble> ret(myF1TSC->getFieldAtLevel(type,meshDimRelToMax,std::string(),renumPol,this,arr,*contentNotNullBase()));
9756 MCAuto<MEDCouplingFieldInt> ret2(MEDFileIntField1TS::SetDataArrayDoubleInIntField(ret,arr));
9761 * Returns a new MEDCouplingFieldInt of a given type, of a given time step, lying on
9762 * the top level cells of the first mesh in MED file.
9763 * For more info, see \ref AdvMEDLoaderAPIFieldRW
9764 * \param [in] type - a spatial discretization of interest.
9765 * \param [in] iteration - the iteration number of a required time step.
9766 * \param [in] order - the iteration order number of required time step.
9767 * \param [in] renumPol - specifies how to permute values of the result field according to
9768 * the optional numbers of cells and nodes, if any. The valid values are
9769 * - 0 - do not permute.
9770 * - 1 - permute cells.
9771 * - 2 - permute nodes.
9772 * - 3 - permute cells and nodes.
9774 * \return MEDCouplingFieldInt * - a new instance of MEDCouplingFieldDouble. The
9775 * caller is to delete this field using decrRef() as it is no more needed.
9776 * \throw If the MED file is not readable.
9777 * \throw If there is no mesh in the MED file.
9778 * \throw If no field values of the required parameters are available.
9780 MEDCouplingFieldInt *MEDFileIntFieldMultiTS::getFieldAtTopLevel(TypeOfField type, int iteration, int order, int renumPol) const
9782 const MEDFileAnyTypeField1TSWithoutSDA& myF1TS(contentNotNullBase()->getTimeStepEntry(iteration,order));
9783 const MEDFileIntField1TSWithoutSDA *myF1TSC(dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS));
9785 throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::getFieldAtTopLevel : mismatch of type of field ! INT32 expected !");
9786 MCAuto<DataArray> arr;
9787 MCAuto<MEDCouplingFieldDouble> ret(myF1TSC->getFieldAtTopLevel(type,std::string(),renumPol,this,arr,*contentNotNullBase()));
9788 MCAuto<MEDCouplingFieldInt> ret2(MEDFileIntField1TS::SetDataArrayDoubleInIntField(ret,arr));
9793 * Returns a new MEDCouplingFieldInt of a given type, of a given time step, lying on
9795 * For more info, see \ref AdvMEDLoaderAPIFieldRW
9796 * \param [in] type - a spatial discretization of interest.
9797 * \param [in] iteration - the iteration number of a required time step.
9798 * \param [in] order - the iteration order number of required time step.
9799 * \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
9800 * \param [in] mesh - the supporting mesh.
9801 * \param [in] renumPol - specifies how to permute values of the result field according to
9802 * the optional numbers of cells and nodes, if any. The valid values are
9803 * - 0 - do not permute.
9804 * - 1 - permute cells.
9805 * - 2 - permute nodes.
9806 * - 3 - permute cells and nodes.
9808 * \return MEDCouplingFieldInt * - a new instance of MEDCouplingFieldDouble. The
9809 * caller is to delete this field using decrRef() as it is no more needed.
9810 * \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
9811 * \throw If no field of \a this is lying on \a mesh.
9812 * \throw If no field values of the required parameters are available.
9814 MEDCouplingFieldInt *MEDFileIntFieldMultiTS::getFieldOnMeshAtLevel(TypeOfField type, int iteration, int order, int meshDimRelToMax, const MEDFileMesh *mesh, int renumPol) const
9816 const MEDFileAnyTypeField1TSWithoutSDA& myF1TS(contentNotNullBase()->getTimeStepEntry(iteration,order));
9817 const MEDFileIntField1TSWithoutSDA *myF1TSC(dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS));
9819 throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::getFieldOnMeshAtLevel : mismatch of type of field ! INT32 expected !");
9820 MCAuto<DataArray> arr;
9821 MCAuto<MEDCouplingFieldDouble> ret(myF1TSC->getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,this,mesh,arr,*contentNotNullBase()));
9822 MCAuto<MEDCouplingFieldInt> ret2(MEDFileIntField1TS::SetDataArrayDoubleInIntField(ret,arr));
9827 * Returns a new MEDCouplingFieldInt of given type, of a given time step, lying on a
9829 * For more info, see \ref AdvMEDLoaderAPIFieldRW
9830 * \param [in] type - a spatial discretization of the new field.
9831 * \param [in] iteration - the iteration number of a required time step.
9832 * \param [in] order - the iteration order number of required time step.
9833 * \param [in] mesh - the supporting mesh.
9834 * \param [out] arrOut - the DataArrayInt containing values of field.
9835 * \param [in] renumPol - specifies how to permute values of the result field according to
9836 * the optional numbers of cells and nodes, if any. The valid values are
9837 * - 0 - do not permute.
9838 * - 1 - permute cells.
9839 * - 2 - permute nodes.
9840 * - 3 - permute cells and nodes.
9842 * \return MEDCouplingFieldInt * - a new instance of MEDCouplingFieldDouble. The
9843 * caller is to delete this field using decrRef() as it is no more needed.
9844 * \throw If no field of \a this is lying on \a mesh.
9845 * \throw If no field values of the required parameters are available.
9847 MEDCouplingFieldInt *MEDFileIntFieldMultiTS::getFieldOnMeshAtLevel(TypeOfField type, int iteration, int order, const MEDCouplingMesh *mesh, int renumPol) const
9849 const MEDFileAnyTypeField1TSWithoutSDA& myF1TS(contentNotNullBase()->getTimeStepEntry(iteration,order));
9850 const MEDFileIntField1TSWithoutSDA *myF1TSC(dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS));
9852 throw INTERP_KERNEL::Exception("MEDFileFieldIntMultiTS::getFieldOnMeshAtLevel : mismatch of type of field ! INT32 expected !");
9853 MCAuto<DataArray> arr;
9854 MCAuto<MEDCouplingFieldDouble> ret(myF1TSC->getFieldOnMeshAtLevel(type,renumPol,this,mesh,0,0,arr,*contentNotNullBase()));
9855 MCAuto<MEDCouplingFieldInt> ret2(MEDFileIntField1TS::SetDataArrayDoubleInIntField(ret,arr));
9860 * This method has a close behaviour than MEDFileIntFieldMultiTS::getFieldAtLevel.
9861 * This method is called 'old' because the user should give the mesh name he wants to use for it's field.
9862 * This method is useful for MED2 file format when field on different mesh was autorized.
9864 MEDCouplingFieldInt *MEDFileIntFieldMultiTS::getFieldAtLevelOld(TypeOfField type, int iteration, int order, const std::string& mname, int meshDimRelToMax, int renumPol) const
9866 const MEDFileAnyTypeField1TSWithoutSDA& myF1TS(contentNotNullBase()->getTimeStepEntry(iteration,order));
9867 const MEDFileIntField1TSWithoutSDA *myF1TSC(dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS));
9869 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldOnMeshAtLevel : mismatch of type of field ! INT32 expected !");
9870 MCAuto<DataArray> arr;
9871 MCAuto<MEDCouplingFieldDouble> ret(myF1TSC->getFieldAtLevel(type,meshDimRelToMax,mname,renumPol,this,arr,*contentNotNullBase()));
9872 MCAuto<MEDCouplingFieldInt> ret2(MEDFileIntField1TS::SetDataArrayDoubleInIntField(ret,arr));
9877 * Returns values and a profile of the field of a given type, of a given time step,
9878 * lying on a given support.
9879 * For more info, see \ref AdvMEDLoaderAPIFieldRW
9880 * \param [in] type - a spatial discretization of the field.
9881 * \param [in] iteration - the iteration number of a required time step.
9882 * \param [in] order - the iteration order number of required time step.
9883 * \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
9884 * \param [in] mesh - the supporting mesh.
9885 * \param [out] pfl - a new instance of DataArrayInt holding ids of mesh entities the
9886 * field of interest lies on. If the field lies on all entities of the given
9887 * dimension, all ids in \a pfl are zero. The caller is to delete this array
9888 * using decrRef() as it is no more needed.
9889 * \param [in] glob - the global data storing profiles and localization.
9890 * \return DataArrayInt * - a new instance of DataArrayInt holding values of the
9891 * field. The caller is to delete this array using decrRef() as it is no more needed.
9892 * \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
9893 * \throw If no field of \a this is lying on \a mesh.
9894 * \throw If no field values of the required parameters are available.
9896 DataArrayInt *MEDFileIntFieldMultiTS::getFieldWithProfile(TypeOfField type, int iteration, int order, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt *&pfl) const
9898 const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
9899 const MEDFileIntField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS);
9901 throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::getFieldWithProfile : mismatch of type of field ! INT32 expected !");
9902 MCAuto<DataArray> ret=myF1TSC->getFieldWithProfile(type,meshDimRelToMax,mesh,pfl,this,*contentNotNullBase());
9903 return MEDFileIntField1TS::ReturnSafelyDataArrayInt(ret);
9907 * Returns a new MEDFileIntField1TS holding data of a given time step of \a this field.
9908 * \param [in] pos - a time step id.
9909 * \return MEDFileIntField1TS * - a new instance of MEDFileIntField1TS. The caller is to
9910 * delete this field using decrRef() as it is no more needed.
9911 * \throw If \a pos is not a valid time step id.
9913 MEDFileIntField1TS *MEDFileIntFieldMultiTS::getTimeStepAtPos(int pos) const
9915 const MEDFileAnyTypeField1TSWithoutSDA *item=contentNotNullBase()->getTimeStepAtPos2(pos);
9918 std::ostringstream oss; oss << "MEDFileIntFieldMultiTS::getTimeStepAtPos : field at pos #" << pos << " is null !";
9919 throw INTERP_KERNEL::Exception(oss.str());
9921 const MEDFileIntField1TSWithoutSDA *itemC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(item);
9924 MCAuto<MEDFileIntField1TS> ret=MEDFileIntField1TS::New(*itemC,false);
9925 ret->shallowCpyGlobs(*this);
9928 std::ostringstream oss; oss << "MEDFileIntFieldMultiTS::getTimeStepAtPos : type of field at pos #" << pos << " is not INT32 !";
9929 throw INTERP_KERNEL::Exception(oss.str());
9933 * Adds a MEDCouplingFieldInt to \a this as another time step. The underlying mesh of
9934 * the given field is checked if its elements are sorted suitable for writing to MED file
9935 * ("STB" stands for "Sort By Type"), if not, an exception is thrown.
9936 * For more info, see \ref AdvMEDLoaderAPIFieldRW
9937 * \param [in] field - the field to add to \a this.
9938 * \throw If the name of \a field is empty.
9939 * \throw If the data array of \a field is not set.
9940 * \throw If existing time steps have different name or number of components than \a field.
9941 * \throw If the underlying mesh of \a field has no name.
9942 * \throw If elements in the mesh are not in the order suitable for writing to the MED file.
9944 void MEDFileIntFieldMultiTS::appendFieldNoProfileSBT(const MEDCouplingFieldInt *field)
9946 MCAuto<MEDCouplingFieldDouble> field2(MEDFileIntField1TS::ConvertFieldIntToFieldDouble(field));
9947 contentNotNull()->appendFieldNoProfileSBT(field2,field->getArray(),*this);
9951 * Adds a MEDCouplingFieldDouble to \a this as another time step.
9952 * The mesh support of input parameter \a field is ignored here, it can be NULL.
9953 * The support of field \a field is expected to be those computed with the input parameter \a mesh, \a meshDimRelToMax,
9956 * This method will check that the field based on the computed support is coherent. If not an exception will be thrown.
9957 * A new profile is added only if no equal profile is missing.
9958 * For more info, see \ref AdvMEDLoaderAPIFieldRW
9959 * \param [in] field - the field to add to \a this. The field double values and mesh support are ignored.
9960 * \param [in] arrOfVals - the values of the field \a field used.
9961 * \param [in] mesh - the supporting mesh of \a field.
9962 * \param [in] meshDimRelToMax - a relative dimension of mesh entities \a field lies on (useless if field spatial discretization is ON_NODES).
9963 * \param [in] profile - ids of mesh entities on which corresponding field values lie.
9964 * \throw If either \a field or \a mesh or \a profile has an empty name.
9965 * \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
9966 * \throw If the data array of \a field is not set.
9967 * \throw If the data array of \a this is already allocated but has different number of
9968 * components than \a field.
9969 * \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
9970 * \sa setFieldNoProfileSBT()
9972 void MEDFileIntFieldMultiTS::appendFieldProfile(const MEDCouplingFieldInt *field, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile)
9974 MCAuto<MEDCouplingFieldDouble> field2(MEDFileIntField1TS::ConvertFieldIntToFieldDouble(field));
9975 contentNotNull()->appendFieldProfile(field2,field->getArray(),mesh,meshDimRelToMax,profile,*this);
9978 const MEDFileIntFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTS::contentNotNull() const
9980 const MEDFileAnyTypeFieldMultiTSWithoutSDA *pt(_content);
9982 throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::contentNotNull : the content pointer is null !");
9983 const MEDFileIntFieldMultiTSWithoutSDA *ret=dynamic_cast<const MEDFileIntFieldMultiTSWithoutSDA *>(pt);
9985 throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::contentNotNull : the content pointer is not null but it is not of type int ! Reason is maybe that the read field has not the type INT32 !");
9989 MEDFileIntFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTS::contentNotNull()
9991 MEDFileAnyTypeFieldMultiTSWithoutSDA *pt(_content);
9993 throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::contentNotNull : the non const content pointer is null !");
9994 MEDFileIntFieldMultiTSWithoutSDA *ret=dynamic_cast<MEDFileIntFieldMultiTSWithoutSDA *>(pt);
9996 throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::contentNotNull : the non const content pointer is not null but it is not of type int ! Reason is maybe that the read field has not the type INT32 !");
10000 MEDFileIntFieldMultiTS::MEDFileIntFieldMultiTS()
10002 _content=new MEDFileIntFieldMultiTSWithoutSDA;
10005 MEDFileIntFieldMultiTS::MEDFileIntFieldMultiTS(const MEDFileIntFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent):MEDFileAnyTypeFieldMultiTS(other,shallowCopyOfContent)
10009 MEDFileIntFieldMultiTS::MEDFileIntFieldMultiTS(med_idt fid, bool loadAll, const MEDFileMeshes *ms)
10010 try:MEDFileAnyTypeFieldMultiTS(fid,loadAll,ms)
10013 catch(INTERP_KERNEL::Exception& e)
10016 MEDFileIntFieldMultiTS::MEDFileIntFieldMultiTS(med_idt fid, const std::string& fieldName, bool loadAll, const MEDFileMeshes *ms, const std::vector< std::pair<TypeOfField,INTERP_KERNEL::NormalizedCellType> > *entities)
10017 try:MEDFileAnyTypeFieldMultiTS(fid,fieldName,loadAll,ms,entities)
10020 catch(INTERP_KERNEL::Exception& e)
10023 DataArrayInt *MEDFileIntFieldMultiTS::getUndergroundDataArray(int iteration, int order) const
10025 return static_cast<DataArrayInt *>(contentNotNull()->getUndergroundDataArray(iteration,order));
10028 MEDFileIntFieldMultiTS *MEDFileIntFieldMultiTS::buildNewEmpty() const
10030 return MEDFileIntFieldMultiTS::New();
10035 MEDFileFields *MEDFileFields::New()
10037 return new MEDFileFields;
10040 MEDFileFields *MEDFileFields::New(const std::string& fileName, bool loadAll)
10042 MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
10043 return new MEDFileFields(fid,loadAll,0,0);
10046 MEDFileFields *MEDFileFields::LoadPartOf(const std::string& fileName, bool loadAll, const MEDFileMeshes *ms)
10048 MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
10049 return new MEDFileFields(fid,loadAll,ms,0);
10052 MEDFileFields *MEDFileFields::LoadSpecificEntities(const std::string& fileName, const std::vector< std::pair<TypeOfField,INTERP_KERNEL::NormalizedCellType> >& entities, bool loadAll)
10054 MEDFileUtilities::CheckFileForRead(fileName);
10055 MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(fileName));
10056 return new MEDFileFields(fid,loadAll,0,&entities);
10059 std::size_t MEDFileFields::getHeapMemorySizeWithoutChildren() const
10061 std::size_t ret(MEDFileFieldGlobsReal::getHeapMemorySizeWithoutChildren());
10062 ret+=_fields.capacity()*sizeof(MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA>);
10066 std::vector<const BigMemoryObject *> MEDFileFields::getDirectChildrenWithNull() const
10068 std::vector<const BigMemoryObject *> ret;
10069 for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
10070 ret.push_back((const MEDFileAnyTypeFieldMultiTSWithoutSDA *)*it);
10074 MEDFileFields *MEDFileFields::deepCopy() const
10076 MCAuto<MEDFileFields> ret=shallowCpy();
10078 for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
10080 if((const MEDFileAnyTypeFieldMultiTSWithoutSDA*)*it)
10081 ret->_fields[i]=(*it)->deepCopy();
10083 ret->deepCpyGlobs(*this);
10087 MEDFileFields *MEDFileFields::shallowCpy() const
10089 return new MEDFileFields(*this);
10093 * 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
10094 * 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.
10095 * If \a areThereSomeForgottenTS is set to true, only the sorted intersection of time steps present for all fields in \a this will be returned.
10097 * \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.
10098 * \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.
10100 * \sa MEDFileFields::partOfThisLyingOnSpecifiedTimeSteps, MEDFileFields::partOfThisNotLyingOnSpecifiedTimeSteps
10102 std::vector< std::pair<int,int> > MEDFileFields::getCommonIterations(bool& areThereSomeForgottenTS) const
10104 std::set< std::pair<int,int> > s;
10105 bool firstShot=true;
10106 areThereSomeForgottenTS=false;
10107 for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
10109 if(!(const MEDFileAnyTypeFieldMultiTSWithoutSDA*)*it)
10111 std::vector< std::pair<int,int> > v=(*it)->getIterations();
10112 std::set< std::pair<int,int> > s1; std::copy(v.begin(),v.end(),std::inserter(s1,s1.end()));
10114 { s=s1; firstShot=false; }
10117 std::set< std::pair<int,int> > s2; std::set_intersection(s.begin(),s.end(),s1.begin(),s1.end(),std::inserter(s2,s2.end()));
10119 areThereSomeForgottenTS=true;
10123 std::vector< std::pair<int,int> > ret;
10124 std::copy(s.begin(),s.end(),std::back_insert_iterator< std::vector< std::pair<int,int> > >(ret));
10128 int MEDFileFields::getNumberOfFields() const
10130 return _fields.size();
10133 std::vector<std::string> MEDFileFields::getFieldsNames() const
10135 std::vector<std::string> ret(_fields.size());
10137 for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
10139 const MEDFileAnyTypeFieldMultiTSWithoutSDA *f=(*it);
10142 ret[i]=f->getName();
10146 std::ostringstream oss; oss << "MEDFileFields::getFieldsNames : At rank #" << i << " field is not defined !";
10147 throw INTERP_KERNEL::Exception(oss.str());
10153 std::vector<std::string> MEDFileFields::getMeshesNames() const
10155 std::vector<std::string> ret;
10156 for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
10158 const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur(*it);
10160 ret.push_back(cur->getMeshName());
10165 std::string MEDFileFields::simpleRepr() const
10167 std::ostringstream oss;
10168 oss << "(*****************)\n(* MEDFileFields *)\n(*****************)\n\n";
10173 void MEDFileFields::simpleRepr(int bkOffset, std::ostream& oss) const
10175 int nbOfFields=getNumberOfFields();
10176 std::string startLine(bkOffset,' ');
10177 oss << startLine << "There are " << nbOfFields << " fields in this :" << std::endl;
10179 for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
10181 const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur=(*it);
10184 oss << startLine << " - # "<< i << " has the following name : \"" << cur->getName() << "\"." << std::endl;
10188 oss << startLine << " - not defined !" << std::endl;
10192 for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
10194 const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur=(*it);
10195 std::string chapter(17,'0'+i);
10196 oss << startLine << chapter << std::endl;
10199 cur->simpleRepr(bkOffset+2,oss,i);
10203 oss << startLine << " - not defined !" << std::endl;
10205 oss << startLine << chapter << std::endl;
10207 simpleReprGlobs(oss);
10210 MEDFileFields::MEDFileFields()
10214 MEDFileFields::MEDFileFields(med_idt fid, bool loadAll, const MEDFileMeshes *ms, const std::vector< std::pair<TypeOfField,INTERP_KERNEL::NormalizedCellType> > *entities)
10215 try:MEDFileFieldGlobsReal(fid)
10217 int nbFields(MEDnField(fid));
10218 _fields.resize(nbFields);
10219 med_field_type typcha;
10220 for(int i=0;i<nbFields;i++)
10222 std::vector<std::string> infos;
10223 std::string fieldName,dtunit;
10224 int nbOfStep(MEDFileAnyTypeField1TS::LocateField2(fid,i,false,fieldName,typcha,infos,dtunit));
10229 _fields[i]=MEDFileFieldMultiTSWithoutSDA::New(fid,fieldName.c_str(),typcha,infos,nbOfStep,dtunit,loadAll,ms,entities);
10234 _fields[i]=MEDFileIntFieldMultiTSWithoutSDA::New(fid,fieldName.c_str(),typcha,infos,nbOfStep,dtunit,loadAll,ms,entities);
10239 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] !";
10240 throw INTERP_KERNEL::Exception(oss.str());
10244 loadAllGlobals(fid);
10246 catch(INTERP_KERNEL::Exception& e)
10251 void MEDFileFields::writeLL(med_idt fid) const
10254 writeGlobals(fid,*this);
10255 for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
10257 const MEDFileAnyTypeFieldMultiTSWithoutSDA *elt=*it;
10260 std::ostringstream oss; oss << "MEDFileFields::write : at rank #" << i << "/" << _fields.size() << " field is empty !";
10261 throw INTERP_KERNEL::Exception(oss.str());
10263 elt->writeLL(fid,*this);
10268 * This method alloc the arrays and load potentially huge arrays contained in this field.
10269 * This method should be called when a MEDFileAnyTypeFieldMultiTS::New constructor has been with false as the last parameter.
10270 * This method can be also called to refresh or reinit values from a file.
10272 * \throw If the fileName is not set or points to a non readable MED file.
10274 void MEDFileFields::loadArrays()
10276 if(getFileName().empty())
10277 throw INTERP_KERNEL::Exception("MEDFileFields::loadArrays : the structure does not come from a file !");
10278 MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(getFileName()));
10279 for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
10281 MEDFileAnyTypeFieldMultiTSWithoutSDA *elt(*it);
10283 elt->loadBigArraysRecursively(fid,*elt);
10288 * This method behaves as MEDFileFields::loadArrays does, the first call, if \a this was built using a file without loading big arrays.
10289 * But once data loaded once, this method does nothing.
10291 * \throw If the fileName is not set or points to a non readable MED file.
10292 * \sa MEDFileFields::loadArrays, MEDFileFields::unloadArrays
10294 void MEDFileFields::loadArraysIfNecessary()
10296 if(!getFileName().empty())
10298 MEDFileUtilities::AutoFid fid(OpenMEDFileForRead(getFileName()));
10299 for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
10301 MEDFileAnyTypeFieldMultiTSWithoutSDA *elt(*it);
10303 elt->loadBigArraysRecursivelyIfNecessary(fid,*elt);
10309 * This method releases potentially big data arrays and so returns to the same heap memory than status loaded with 'loadAll' parameter set to false.
10310 * \b WARNING, this method does release arrays even if \a this does not come from a load of a MED file.
10311 * So this method can lead to a loss of data. If you want to unload arrays safely call MEDFileFields::unloadArraysWithoutDataLoss instead.
10313 * \sa MEDFileFields::loadArrays, MEDFileFields::loadArraysIfNecessary, MEDFileFields::unloadArraysWithoutDataLoss
10315 void MEDFileFields::unloadArrays()
10317 for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
10319 MEDFileAnyTypeFieldMultiTSWithoutSDA *elt(*it);
10321 elt->unloadArrays();
10326 * 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.
10327 * This method is the symetrical method of MEDFileFields::loadArraysIfNecessary.
10328 * This method is useful to reduce \b safely amount of heap memory necessary for \a this by using MED file as database.
10330 * \sa MEDFileFields::loadArraysIfNecessary
10332 void MEDFileFields::unloadArraysWithoutDataLoss()
10334 if(!getFileName().empty())
10338 std::vector<std::string> MEDFileFields::getPflsReallyUsed() const
10340 std::vector<std::string> ret;
10341 std::set<std::string> ret2;
10342 for(std::vector< MCAuto< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::const_iterator it=_fields.begin();it!=_fields.end();it++)
10344 std::vector<std::string> tmp=(*it)->getPflsReallyUsed2();
10345 for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
10346 if(ret2.find(*it2)==ret2.end())
10348 ret.push_back(*it2);
10355 std::vector<std::string> MEDFileFields::getLocsReallyUsed() const
10357 std::vector<std::string> ret;
10358 std::set<std::string> ret2;
10359 for(std::vector< MCAuto< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::const_iterator it=_fields.begin();it!=_fields.end();it++)
10361 std::vector<std::string> tmp=(*it)->getLocsReallyUsed2();
10362 for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
10363 if(ret2.find(*it2)==ret2.end())
10365 ret.push_back(*it2);
10372 std::vector<std::string> MEDFileFields::getPflsReallyUsedMulti() const
10374 std::vector<std::string> ret;
10375 for(std::vector< MCAuto< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::const_iterator it=_fields.begin();it!=_fields.end();it++)
10377 std::vector<std::string> tmp=(*it)->getPflsReallyUsedMulti2();
10378 ret.insert(ret.end(),tmp.begin(),tmp.end());
10383 std::vector<std::string> MEDFileFields::getLocsReallyUsedMulti() const
10385 std::vector<std::string> ret;
10386 for(std::vector< MCAuto< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::const_iterator it=_fields.begin();it!=_fields.end();it++)
10388 std::vector<std::string> tmp=(*it)->getLocsReallyUsed2();
10389 ret.insert(ret.end(),tmp.begin(),tmp.end());
10394 void MEDFileFields::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
10396 for(std::vector< MCAuto< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::iterator it=_fields.begin();it!=_fields.end();it++)
10397 (*it)->changePflsRefsNamesGen2(mapOfModif);
10400 void MEDFileFields::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
10402 for(std::vector< MCAuto< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::iterator it=_fields.begin();it!=_fields.end();it++)
10403 (*it)->changeLocsRefsNamesGen2(mapOfModif);
10406 void MEDFileFields::resize(int newSize)
10408 _fields.resize(newSize);
10411 void MEDFileFields::pushFields(const std::vector<MEDFileAnyTypeFieldMultiTS *>& fields)
10413 for(std::vector<MEDFileAnyTypeFieldMultiTS *>::const_iterator it=fields.begin();it!=fields.end();it++)
10417 void MEDFileFields::pushField(MEDFileAnyTypeFieldMultiTS *field)
10420 throw INTERP_KERNEL::Exception("MEDFileFields::pushMesh : invalid input pointer ! should be different from 0 !");
10421 _fields.push_back(field->getContent());
10422 appendGlobs(*field,1e-12);
10425 void MEDFileFields::setFieldAtPos(int i, MEDFileAnyTypeFieldMultiTS *field)
10428 throw INTERP_KERNEL::Exception("MEDFileFields::setFieldAtPos : invalid input pointer ! should be different from 0 !");
10429 if(i>=(int)_fields.size())
10430 _fields.resize(i+1);
10431 _fields[i]=field->getContent();
10432 appendGlobs(*field,1e-12);
10435 void MEDFileFields::destroyFieldAtPos(int i)
10437 destroyFieldsAtPos(&i,&i+1);
10440 void MEDFileFields::destroyFieldsAtPos(const int *startIds, const int *endIds)
10442 std::vector<bool> b(_fields.size(),true);
10443 for(const int *i=startIds;i!=endIds;i++)
10445 if(*i<0 || *i>=(int)_fields.size())
10447 std::ostringstream oss; oss << "MEDFileFields::destroyFieldsAtPos : Invalid given id in input (" << *i << ") should be in [0," << _fields.size() << ") !";
10448 throw INTERP_KERNEL::Exception(oss.str());
10452 std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> > fields(std::count(b.begin(),b.end(),true));
10454 for(std::size_t i=0;i<_fields.size();i++)
10456 fields[j++]=_fields[i];
10460 void MEDFileFields::destroyFieldsAtPos2(int bg, int end, int step)
10462 static const char msg[]="MEDFileFields::destroyFieldsAtPos2";
10463 int nbOfEntriesToKill=DataArrayInt::GetNumberOfItemGivenBESRelative(bg,end,step,msg);
10464 std::vector<bool> b(_fields.size(),true);
10466 for(int i=0;i<nbOfEntriesToKill;i++,k+=step)
10468 if(k<0 || k>=(int)_fields.size())
10470 std::ostringstream oss; oss << "MEDFileFields::destroyFieldsAtPos2 : Invalid given id in input (" << k << ") should be in [0," << _fields.size() << ") !";
10471 throw INTERP_KERNEL::Exception(oss.str());
10475 std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> > fields(std::count(b.begin(),b.end(),true));
10477 for(std::size_t i=0;i<_fields.size();i++)
10479 fields[j++]=_fields[i];
10483 bool MEDFileFields::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab)
10486 for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
10488 MEDFileAnyTypeFieldMultiTSWithoutSDA *cur(*it);
10490 ret=cur->changeMeshNames(modifTab) || ret;
10496 * \param [in] meshName the name of the mesh that will be renumbered.
10497 * \param [in] oldCode is of format returned by MEDCouplingUMesh::getDistributionOfTypes. And for each *i* oldCode[3*i+2] gives the position (MEDFileUMesh::PutInThirdComponentOfCodeOffset).
10498 * This code corresponds to the distribution of types in the corresponding mesh.
10499 * \param [in] newCode idem to param \a oldCode except that here the new distribution is given.
10500 * \param [in] renumO2N the old to new renumber array.
10501 * \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
10502 * field in \a this.
10504 bool MEDFileFields::renumberEntitiesLyingOnMesh(const std::string& meshName, const std::vector<int>& oldCode, const std::vector<int>& newCode, const DataArrayInt *renumO2N)
10507 for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
10509 MEDFileAnyTypeFieldMultiTSWithoutSDA *fmts(*it);
10512 ret=fmts->renumberEntitiesLyingOnMesh(meshName,oldCode,newCode,renumO2N,*this) || ret;
10519 * Return an extraction of \a this using \a extractDef map to specify the extraction.
10520 * The keys of \a extractDef is level relative to max ext of \a mm mesh.
10522 * \return A new object that the caller is responsible to deallocate.
10524 MEDFileFields *MEDFileFields::extractPart(const std::map<int, MCAuto<DataArrayInt> >& extractDef, MEDFileMesh *mm) const
10527 throw INTERP_KERNEL::Exception("MEDFileFields::extractPart : input mesh is NULL !");
10528 MCAuto<MEDFileFields> fsOut(MEDFileFields::New());
10529 int nbFields(getNumberOfFields());
10530 for(int i=0;i<nbFields;i++)
10532 MCAuto<MEDFileAnyTypeFieldMultiTS> fmts(getFieldAtPos(i));
10535 std::ostringstream oss; oss << "MEDFileFields::extractPart : at pos #" << i << " field is null !";
10536 throw INTERP_KERNEL::Exception(oss.str());
10538 MCAuto<MEDFileAnyTypeFieldMultiTS> fmtsOut(fmts->extractPart(extractDef,mm));
10539 fsOut->pushField(fmtsOut);
10541 return fsOut.retn();
10544 MEDFileAnyTypeFieldMultiTS *MEDFileFields::getFieldAtPos(int i) const
10546 if(i<0 || i>=(int)_fields.size())
10548 std::ostringstream oss; oss << "MEDFileFields::getFieldAtPos : Invalid given id in input (" << i << ") should be in [0," << _fields.size() << ") !";
10549 throw INTERP_KERNEL::Exception(oss.str());
10551 const MEDFileAnyTypeFieldMultiTSWithoutSDA *fmts=_fields[i];
10554 MCAuto<MEDFileAnyTypeFieldMultiTS> ret;
10555 const MEDFileFieldMultiTSWithoutSDA *fmtsC=dynamic_cast<const MEDFileFieldMultiTSWithoutSDA *>(fmts);
10556 const MEDFileIntFieldMultiTSWithoutSDA *fmtsC2=dynamic_cast<const MEDFileIntFieldMultiTSWithoutSDA *>(fmts);
10558 ret=MEDFileFieldMultiTS::New(*fmtsC,false);
10560 ret=MEDFileIntFieldMultiTS::New(*fmtsC2,false);
10563 std::ostringstream oss; oss << "MEDFileFields::getFieldAtPos : At pos #" << i << " field is neither double (FLOAT64) nor integer (INT32) !";
10564 throw INTERP_KERNEL::Exception(oss.str());
10566 ret->shallowCpyGlobs(*this);
10571 * Return a shallow copy of \a this reduced to the fields ids defined in [ \a startIds , endIds ).
10572 * This method is accessible in python using __getitem__ with a list in input.
10573 * \return a new object that the caller should deal with.
10575 MEDFileFields *MEDFileFields::buildSubPart(const int *startIds, const int *endIds) const
10577 MCAuto<MEDFileFields> ret=shallowCpy();
10578 std::size_t sz=std::distance(startIds,endIds);
10579 std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> > fields(sz);
10581 for(const int *i=startIds;i!=endIds;i++,j++)
10583 if(*i<0 || *i>=(int)_fields.size())
10585 std::ostringstream oss; oss << "MEDFileFields::buildSubPart : Invalid given id in input (" << *i << ") should be in [0," << _fields.size() << ") !";
10586 throw INTERP_KERNEL::Exception(oss.str());
10588 fields[j]=_fields[*i];
10590 ret->_fields=fields;
10594 MEDFileAnyTypeFieldMultiTS *MEDFileFields::getFieldWithName(const std::string& fieldName) const
10596 return getFieldAtPos(getPosFromFieldName(fieldName));
10600 * This method removes, if any, fields in \a this having no time steps.
10601 * 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.
10603 * If false is returned \a this does not contain such fields. If false is returned this method can be considered as const.
10605 bool MEDFileFields::removeFieldsWithoutAnyTimeStep()
10607 std::vector<MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> > newFields;
10608 for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
10610 const MEDFileAnyTypeFieldMultiTSWithoutSDA *elt(*it);
10613 if(elt->getNumberOfTS()>0)
10614 newFields.push_back(*it);
10617 if(_fields.size()==newFields.size())
10624 * This method returns a new object containing part of \a this fields lying on mesh name specified by the input parameter \a meshName.
10625 * This method can be seen as a filter applied on \a this, that returns an object containing
10626 * 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
10627 * shallow copied from \a this.
10629 * \param [in] meshName - the name of the mesh on w
10630 * \return a new object that the caller should deal with.
10632 MEDFileFields *MEDFileFields::partOfThisLyingOnSpecifiedMeshName(const std::string& meshName) const
10634 MCAuto<MEDFileFields> ret=MEDFileFields::New();
10635 for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
10637 const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur=(*it);
10640 if(cur->getMeshName()==meshName)
10643 MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> cur2(const_cast<MEDFileAnyTypeFieldMultiTSWithoutSDA *>(cur));
10644 ret->_fields.push_back(cur2);
10647 ret->shallowCpyOnlyUsedGlobs(*this);
10652 * This method returns a new object containing part of \a this fields lying ** exactly ** on the time steps specified by input parameter \a timeSteps.
10653 * Input time steps are specified using a pair of integer (iteration, order).
10654 * 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,
10655 * but for each multitimestep only the time steps in \a timeSteps are kept.
10656 * Typically the input parameter \a timeSteps comes from the call of MEDFileFields::getCommonIterations.
10658 * The returned object points to shallow copy of elements in \a this.
10660 * \param [in] timeSteps - the time steps given by a vector of pair of integers (iteration,order)
10661 * \throw If there is a field in \a this that is \b not defined on a time step in the input \a timeSteps.
10662 * \sa MEDFileFields::getCommonIterations, MEDFileFields::partOfThisNotLyingOnSpecifiedTimeSteps
10664 MEDFileFields *MEDFileFields::partOfThisLyingOnSpecifiedTimeSteps(const std::vector< std::pair<int,int> >& timeSteps) const
10666 MCAuto<MEDFileFields> ret=MEDFileFields::New();
10667 for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
10669 const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur=(*it);
10672 MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> elt=cur->partOfThisLyingOnSpecifiedTimeSteps(timeSteps);
10673 ret->_fields.push_back(elt);
10675 ret->shallowCpyOnlyUsedGlobs(*this);
10680 * \sa MEDFileFields::getCommonIterations, MEDFileFields::partOfThisLyingOnSpecifiedTimeSteps
10682 MEDFileFields *MEDFileFields::partOfThisNotLyingOnSpecifiedTimeSteps(const std::vector< std::pair<int,int> >& timeSteps) const
10684 MCAuto<MEDFileFields> ret=MEDFileFields::New();
10685 for(std::vector< MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
10687 const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur=(*it);
10690 MCAuto<MEDFileAnyTypeFieldMultiTSWithoutSDA> elt=cur->partOfThisNotLyingOnSpecifiedTimeSteps(timeSteps);
10691 if(elt->getNumberOfTS()!=0)
10692 ret->_fields.push_back(elt);
10694 ret->shallowCpyOnlyUsedGlobs(*this);
10698 MEDFileFieldsIterator *MEDFileFields::iterator()
10700 return new MEDFileFieldsIterator(this);
10703 int MEDFileFields::getPosFromFieldName(const std::string& fieldName) const
10705 std::string tmp(fieldName);
10706 std::vector<std::string> poss;
10707 for(std::size_t i=0;i<_fields.size();i++)
10709 const MEDFileAnyTypeFieldMultiTSWithoutSDA *f=_fields[i];
10712 std::string fname(f->getName());
10716 poss.push_back(fname);
10719 std::ostringstream oss; oss << "MEDFileFields::getPosFromFieldName : impossible to find field '" << tmp << "' in this ! Possibilities are : ";
10720 std::copy(poss.begin(),poss.end(),std::ostream_iterator<std::string>(oss,", "));
10722 throw INTERP_KERNEL::Exception(oss.str());
10725 MEDFileFieldsIterator::MEDFileFieldsIterator(MEDFileFields *fs):_fs(fs),_iter_id(0),_nb_iter(0)
10730 _nb_iter=fs->getNumberOfFields();
10734 MEDFileFieldsIterator::~MEDFileFieldsIterator()
10738 MEDFileAnyTypeFieldMultiTS *MEDFileFieldsIterator::nextt()
10740 if(_iter_id<_nb_iter)
10742 MEDFileFields *fs(_fs);
10744 return fs->getFieldAtPos(_iter_id++);