1 // Copyright (C) 2007-2014 CEA/DEN, EDF R&D
3 // This library is free software; you can redistribute it and/or
4 // modify it under the terms of the GNU Lesser General Public
5 // License as published by the Free Software Foundation; either
6 // version 2.1 of the License, or (at your option) any later version.
8 // This library is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 // Lesser General Public License for more details.
13 // You should have received a copy of the GNU Lesser General Public
14 // License along with this library; if not, write to the Free Software
15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
19 // Author : Anthony Geay (CEA/DEN)
21 #include "MEDFileField.hxx"
22 #include "MEDFileMesh.hxx"
23 #include "MEDLoaderBase.hxx"
24 #include "MEDFileUtilities.hxx"
25 #include "MEDFileFieldOverView.hxx"
27 #include "MEDCouplingFieldDouble.hxx"
28 #include "MEDCouplingFieldDiscretization.hxx"
30 #include "InterpKernelAutoPtr.hxx"
31 #include "CellModel.hxx"
36 extern med_geometry_type typmai[MED_N_CELL_FIXED_GEO];
37 extern INTERP_KERNEL::NormalizedCellType typmai2[MED_N_CELL_FIXED_GEO];
38 extern med_geometry_type typmainoeud[1];
39 extern med_geometry_type typmai3[34];
41 using namespace ParaMEDMEM;
43 const char MEDFileField1TSWithoutSDA::TYPE_STR[]="FLOAT64";
44 const char MEDFileIntField1TSWithoutSDA::TYPE_STR[]="INT32";
46 MEDFileFieldLoc *MEDFileFieldLoc::New(med_idt fid, const std::string& locName)
48 return new MEDFileFieldLoc(fid,locName);
51 MEDFileFieldLoc *MEDFileFieldLoc::New(med_idt fid, int id)
53 return new MEDFileFieldLoc(fid,id);
56 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)
58 return new MEDFileFieldLoc(locName,geoType,refCoo,gsCoo,w);
61 MEDFileFieldLoc::MEDFileFieldLoc(med_idt fid, const std::string& locName):_name(locName)
63 med_geometry_type geotype;
64 med_geometry_type sectiongeotype;
66 INTERP_KERNEL::AutoPtr<char> geointerpname=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
67 INTERP_KERNEL::AutoPtr<char> sectionmeshname=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
68 MEDlocalizationInfoByName(fid,locName.c_str(),&geotype,&_dim,&_nb_gauss_pt,geointerpname,sectionmeshname,&nsectionmeshcell,§iongeotype);
69 _geo_type=(INTERP_KERNEL::NormalizedCellType)(std::distance(typmai3,std::find(typmai3,typmai3+34,geotype)));
70 const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
71 _nb_node_per_cell=cm.getNumberOfNodes();
72 _ref_coo.resize(_dim*_nb_node_per_cell);
73 _gs_coo.resize(_dim*_nb_gauss_pt);
74 _w.resize(_nb_gauss_pt);
75 MEDlocalizationRd(fid,locName.c_str(),MED_FULL_INTERLACE,&_ref_coo[0],&_gs_coo[0],&_w[0]);
78 MEDFileFieldLoc::MEDFileFieldLoc(med_idt fid, int id)
80 med_geometry_type geotype;
81 med_geometry_type sectiongeotype;
83 INTERP_KERNEL::AutoPtr<char> locName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
84 INTERP_KERNEL::AutoPtr<char> geointerpname=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
85 INTERP_KERNEL::AutoPtr<char> sectionmeshname=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
86 MEDlocalizationInfo(fid,id+1,locName,&geotype,&_dim,&_nb_gauss_pt,geointerpname,sectionmeshname,&nsectionmeshcell,§iongeotype);
88 _geo_type=(INTERP_KERNEL::NormalizedCellType)(std::distance(typmai3,std::find(typmai3,typmai3+34,geotype)));
89 const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
90 _nb_node_per_cell=cm.getNumberOfNodes();
91 _ref_coo.resize(_dim*_nb_node_per_cell);
92 _gs_coo.resize(_dim*_nb_gauss_pt);
93 _w.resize(_nb_gauss_pt);
94 MEDlocalizationRd(fid,locName,MED_FULL_INTERLACE,&_ref_coo[0],&_gs_coo[0],&_w[0]);
97 MEDFileFieldLoc::MEDFileFieldLoc(const std::string& locName, INTERP_KERNEL::NormalizedCellType geoType,
98 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),
101 const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
102 _dim=cm.getDimension();
103 _nb_node_per_cell=cm.getNumberOfNodes();
104 _nb_gauss_pt=_w.size();
107 MEDFileFieldLoc *MEDFileFieldLoc::deepCpy() const
109 return new MEDFileFieldLoc(*this);
112 std::size_t MEDFileFieldLoc::getHeapMemorySizeWithoutChildren() const
114 return (_ref_coo.capacity()+_gs_coo.capacity()+_w.capacity())*sizeof(double)+_name.capacity();
117 std::vector<const BigMemoryObject *> MEDFileFieldLoc::getDirectChildren() const
119 return std::vector<const BigMemoryObject *>();
122 void MEDFileFieldLoc::simpleRepr(std::ostream& oss) const
124 static const char OFF7[]="\n ";
125 oss << "\"" << _name << "\"" << OFF7;
126 oss << "GeoType=" << INTERP_KERNEL::CellModel::GetCellModel(_geo_type).getRepr() << OFF7;
127 oss << "Dimension=" << _dim << OFF7;
128 oss << "Number of Gauss points=" << _nb_gauss_pt << OFF7;
129 oss << "Number of nodes per cell=" << _nb_node_per_cell << OFF7;
130 oss << "RefCoords="; std::copy(_ref_coo.begin(),_ref_coo.end(),std::ostream_iterator<double>(oss," ")); oss << OFF7;
131 oss << "Weights="; std::copy(_w.begin(),_w.end(),std::ostream_iterator<double>(oss," ")); oss << OFF7;
132 oss << "GaussPtsCoords="; std::copy(_gs_coo.begin(),_gs_coo.end(),std::ostream_iterator<double>(oss," ")); oss << std::endl;
135 void MEDFileFieldLoc::setName(const std::string& name)
140 bool MEDFileFieldLoc::isEqual(const MEDFileFieldLoc& other, double eps) const
142 if(_name!=other._name)
146 if(_nb_gauss_pt!=other._nb_gauss_pt)
148 if(_nb_node_per_cell!=other._nb_node_per_cell)
150 if(_geo_type!=other._geo_type)
152 if(!MEDCouplingGaussLocalization::AreAlmostEqual(_ref_coo,other._ref_coo,eps))
154 if(!MEDCouplingGaussLocalization::AreAlmostEqual(_gs_coo,other._gs_coo,eps))
156 if(!MEDCouplingGaussLocalization::AreAlmostEqual(_w,other._w,eps))
162 void MEDFileFieldLoc::writeLL(med_idt fid) const
164 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);
167 std::string MEDFileFieldLoc::repr() const
169 std::ostringstream oss; oss.precision(15);
170 const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
171 oss << "Localization \"" << _name << "\" :\n" << " - Geometric Type : " << cm.getRepr();
172 oss << "\n - Dimension : " << _dim << "\n - Number of gauss points : ";
173 oss << _nb_gauss_pt << "\n - Number of nodes in cell : " << _nb_node_per_cell;
174 oss << "\n - Ref coords are : ";
175 int sz=_ref_coo.size();
178 int nbOfTuples=sz/_dim;
179 for(int i=0;i<nbOfTuples;i++)
182 for(int j=0;j<_dim;j++)
183 { oss << _ref_coo[i*_dim+j]; if(j!=_dim-1) oss << ", "; }
188 std::copy(_ref_coo.begin(),_ref_coo.end(),std::ostream_iterator<double>(oss," "));
189 oss << "\n - Gauss coords in reference element : ";
193 int nbOfTuples=sz/_dim;
194 for(int i=0;i<nbOfTuples;i++)
197 for(int j=0;j<_dim;j++)
198 { oss << _gs_coo[i*_dim+j]; if(j!=_dim-1) oss << ", "; }
203 std::copy(_gs_coo.begin(),_gs_coo.end(),std::ostream_iterator<double>(oss," "));
204 oss << "\n - Weights of Gauss coords are : "; std::copy(_w.begin(),_w.end(),std::ostream_iterator<double>(oss," "));
208 void MEDFileFieldPerMeshPerTypePerDisc::assignFieldNoProfile(int& start, int offset, int nbOfCells, const MEDCouplingFieldDouble *field, const DataArray *arrr, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc)
210 _type=field->getTypeOfField();
216 getOrCreateAndGetArray()->setContigPartOfSelectedValues2(_start,arrr,offset,offset+nbOfCells,1);
217 _end=_start+nbOfCells;
223 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr=field->getDiscretization()->getOffsetArr(field->getMesh());
224 const int *arrPtr=arr->getConstPointer();
225 getOrCreateAndGetArray()->setContigPartOfSelectedValues2(_start,arrr,arrPtr[offset],arrPtr[offset+nbOfCells],1);
226 _end=_start+(arrPtr[offset+nbOfCells]-arrPtr[offset]);
232 const MEDCouplingFieldDiscretization *disc=field->getDiscretization();
233 const MEDCouplingGaussLocalization& gsLoc=field->getGaussLocalization(_loc_id);
234 const MEDCouplingFieldDiscretizationGauss *disc2=dynamic_cast<const MEDCouplingFieldDiscretizationGauss *>(disc);
236 throw INTERP_KERNEL::Exception("assignFieldNoProfile : invalid call to this method ! Internal Error !");
237 const DataArrayInt *dai=disc2->getArrayOfDiscIds();
238 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> dai2=disc2->getOffsetArr(field->getMesh());
239 const int *dai2Ptr=dai2->getConstPointer();
240 int nbi=gsLoc.getWeights().size();
241 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da2=dai->selectByTupleId2(offset,offset+nbOfCells,1);
242 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da3=da2->getIdsEqual(_loc_id);
243 const int *da3Ptr=da3->getConstPointer();
244 if(da3->getNumberOfTuples()!=nbOfCells)
245 {//profile : for gauss even in NoProfile !!!
246 std::ostringstream oss; oss << "Pfl_" << nasc.getName() << "_" << INTERP_KERNEL::CellModel::GetCellModel(getGeoType()).getRepr() << "_" << _loc_id;
248 da3->setName(_profile.c_str());
249 glob.appendProfile(da3);
251 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da4=DataArrayInt::New();
252 _nval=da3->getNbOfElems();
253 da4->alloc(_nval*nbi,1);
254 int *da4Ptr=da4->getPointer();
255 for(int i=0;i<_nval;i++)
257 int ref=dai2Ptr[offset+da3Ptr[i]];
258 for(int j=0;j<nbi;j++)
261 std::ostringstream oss2; oss2 << "Loc_" << nasc.getName() << "_" << INTERP_KERNEL::CellModel::GetCellModel(getGeoType()).getRepr() << "_" << _loc_id;
262 _localization=oss2.str();
263 getOrCreateAndGetArray()->setContigPartOfSelectedValues(_start,arrr,da4);
264 _end=_start+_nval*nbi;
265 glob.appendLoc(_localization.c_str(),getGeoType(),gsLoc.getRefCoords(),gsLoc.getGaussCoords(),gsLoc.getWeights());
269 throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::assignFieldNoProfile : not implemented yet for such discretization type of field !");
275 * Leaf method of field with profile assignement. This method is the most general one. No optimization is done here.
276 * \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).
277 * \param [in] multiTypePfl is the end user profile specified in high level API
278 * \param [in] idsInPfl is the selection into the \a multiTypePfl whole profile that corresponds to the current geometric type.
279 * \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.
280 * \b WARNING if not null the MED file profile can be subdivided again in case of Gauss points.
281 * \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.
283 void MEDFileFieldPerMeshPerTypePerDisc::assignFieldProfile(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)
286 _type=field->getTypeOfField();
287 std::string pflName(multiTypePfl->getName());
288 std::ostringstream oss; oss << pflName;
289 if(_type!=ON_NODES) { const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(getGeoType()); oss << "_" << cm.getRepr(); } else { oss << "_NODE"; }
293 throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::assignFieldProfile : existing profile with empty name !");
294 if(_type!=ON_GAUSS_PT)
296 locIds->setName(oss.str().c_str());
297 glob.appendProfile(locIds);
306 _nval=idsInPfl->getNumberOfTuples();
307 getOrCreateAndGetArray()->setContigPartOfSelectedValues2(_start,arrr,0,arrr->getNumberOfTuples(),1);
313 _nval=idsInPfl->getNumberOfTuples();
314 getOrCreateAndGetArray()->setContigPartOfSelectedValues(_start,arrr,idsInPfl);
320 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr=field->getDiscretization()->getOffsetArr(mesh);
321 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr2=arr->deltaShiftIndex();
322 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr3=arr2->selectByTupleId(multiTypePfl->begin(),multiTypePfl->end());
323 arr3->computeOffsets2();
324 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmp=idsInPfl->buildExplicitArrByRanges(arr3);
325 int trueNval=tmp->getNumberOfTuples();
326 _nval=idsInPfl->getNumberOfTuples();
327 getOrCreateAndGetArray()->setContigPartOfSelectedValues(_start,arrr,tmp);
328 _end=_start+trueNval;
333 const MEDCouplingFieldDiscretizationGauss *disc2=dynamic_cast<const MEDCouplingFieldDiscretizationGauss *>(field->getDiscretization());
335 throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : invalid call to this method ! Internal Error !");
336 const DataArrayInt *da1=disc2->getArrayOfDiscIds();
337 const MEDCouplingGaussLocalization& gsLoc=field->getGaussLocalization(_loc_id);
338 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da2=da1->selectByTupleId(idsInPfl->begin(),idsInPfl->end());
339 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da3=da2->getIdsEqual(_loc_id);
340 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da4=idsInPfl->selectByTupleId(da3->begin(),da3->end());
342 MEDCouplingAutoRefCountObjectPtr<MEDCouplingMesh> mesh2=mesh->buildPart(multiTypePfl->begin(),multiTypePfl->end());
343 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr=disc2->getOffsetArr(mesh2);
345 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmp=DataArrayInt::New();
347 for(const int *pt=da4->begin();pt!=da4->end();pt++)
348 trueNval+=arr->getIJ(*pt+1,0)-arr->getIJ(*pt,0);
349 tmp->alloc(trueNval,1);
350 int *tmpPtr=tmp->getPointer();
351 for(const int *pt=da4->begin();pt!=da4->end();pt++)
352 for(int j=arr->getIJ(*pt,0);j<arr->getIJ(*pt+1,0);j++)
355 _nval=da4->getNumberOfTuples();
356 getOrCreateAndGetArray()->setContigPartOfSelectedValues(_start,arrr,tmp);
357 _end=_start+trueNval;
358 oss << "_loc_" << _loc_id;
361 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da5=locIds->selectByTupleId(da3->begin(),da3->end());
362 da5->setName(oss.str().c_str());
363 glob.appendProfile(da5);
368 if(da3->getNumberOfTuples()!=nbOfEltsInWholeMesh || !da3->isIdentity())
370 da3->setName(oss.str().c_str());
371 glob.appendProfile(da3);
375 std::ostringstream oss2; oss2 << "Loc_" << nasc.getName() << "_" << INTERP_KERNEL::CellModel::GetCellModel(getGeoType()).getRepr() << "_" << _loc_id;
376 _localization=oss2.str();
377 glob.appendLoc(_localization.c_str(),getGeoType(),gsLoc.getRefCoords(),gsLoc.getGaussCoords(),gsLoc.getWeights());
381 throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::assignFieldProfile : not implemented yet for such discretization type of field !");
386 void MEDFileFieldPerMeshPerTypePerDisc::assignNodeFieldNoProfile(int& start, const MEDCouplingFieldDouble *field, const DataArray *arrr, MEDFileFieldGlobsReal& glob)
389 _nval=arrr->getNumberOfTuples();
390 getOrCreateAndGetArray()->setContigPartOfSelectedValues2(_start,arrr,0,_nval,1);
395 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerTypePerDisc::NewOnRead(MEDFileFieldPerMeshPerType *fath, TypeOfField type, int profileIt)
397 return new MEDFileFieldPerMeshPerTypePerDisc(fath,type,profileIt);
400 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerTypePerDisc::New(MEDFileFieldPerMeshPerType *fath, TypeOfField type, int locId)
402 return new MEDFileFieldPerMeshPerTypePerDisc(fath,type,locId,std::string());
405 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerTypePerDisc::New(const MEDFileFieldPerMeshPerTypePerDisc& other)
407 return new MEDFileFieldPerMeshPerTypePerDisc(other);
410 std::size_t MEDFileFieldPerMeshPerTypePerDisc::getHeapMemorySizeWithoutChildren() const
412 return _profile.capacity()+_localization.capacity()+5*sizeof(int);
415 std::vector<const BigMemoryObject *> MEDFileFieldPerMeshPerTypePerDisc::getDirectChildren() const
417 return std::vector<const BigMemoryObject *>();
420 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerTypePerDisc::deepCpy(MEDFileFieldPerMeshPerType *father) const
422 MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> ret=new MEDFileFieldPerMeshPerTypePerDisc(*this);
427 MEDFileFieldPerMeshPerTypePerDisc::MEDFileFieldPerMeshPerTypePerDisc(MEDFileFieldPerMeshPerType *fath, TypeOfField atype, int profileIt)
428 try:_type(atype),_father(fath),_profile_it(profileIt)
431 catch(INTERP_KERNEL::Exception& e)
436 MEDFileFieldPerMeshPerTypePerDisc::MEDFileFieldPerMeshPerTypePerDisc(MEDFileFieldPerMeshPerType *fath, TypeOfField type, int locId, const std::string& dummy):_type(type),_father(fath),_loc_id(locId)
440 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),_tmp_work1(other._tmp_work1)
444 MEDFileFieldPerMeshPerTypePerDisc::MEDFileFieldPerMeshPerTypePerDisc():_type(ON_CELLS),_father(0),_start(-std::numeric_limits<int>::max()),_end(-std::numeric_limits<int>::max()),
445 _nval(-std::numeric_limits<int>::max()),_loc_id(-std::numeric_limits<int>::max())
449 const MEDFileFieldPerMeshPerType *MEDFileFieldPerMeshPerTypePerDisc::getFather() const
454 void MEDFileFieldPerMeshPerTypePerDisc::loadOnlyStructureOfDataRecursively(med_idt fid, int& start, const MEDFileFieldNameScope& nasc)
456 INTERP_KERNEL::AutoPtr<char> locname=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
457 INTERP_KERNEL::AutoPtr<char> pflname=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
458 std::string fieldName=nasc.getName();
459 std::string meshName=getMeshName();
460 int iteration=getIteration();
461 int order=getOrder();
462 TypeOfField type=getType();
463 INTERP_KERNEL::NormalizedCellType geoType=getGeoType();
465 med_geometry_type mgeoti;
466 med_entity_type menti=MEDFileFieldPerMeshPerType::ConvertIntoMEDFileType(type,geoType,mgeoti);
467 _nval=MEDfieldnValueWithProfile(fid,fieldName.c_str(),iteration,order,menti,mgeoti,_profile_it,MED_COMPACT_PFLMODE,
468 pflname,&profilesize,locname,&nbi);
469 _profile=MEDLoaderBase::buildStringFromFortran(pflname,MED_NAME_SIZE);
470 _localization=MEDLoaderBase::buildStringFromFortran(locname,MED_NAME_SIZE);
472 _end=start+_nval*nbi;
474 if(type==ON_CELLS && !_localization.empty())
476 if(_localization!="MED_GAUSS_ELNO")//For compatibily with MED2.3
477 setType(ON_GAUSS_PT);
480 setType(ON_GAUSS_NE);
481 _localization.clear();
486 void MEDFileFieldPerMeshPerTypePerDisc::loadBigArray(med_idt fid, const MEDFileFieldNameScope& nasc)
488 std::string fieldName=nasc.getName();
489 std::string meshName=getMeshName();
490 int iteration=getIteration();
491 int order=getOrder();
492 TypeOfField type=getType();
493 INTERP_KERNEL::NormalizedCellType geoType=getGeoType();
494 med_geometry_type mgeoti;
495 med_entity_type menti=MEDFileFieldPerMeshPerType::ConvertIntoMEDFileType(type,geoType,mgeoti);
497 throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::loadBigArray : internal error in range !");
500 DataArray *arr=getOrCreateAndGetArray();//arr is not null due to the spec of getOrCreateAndGetArray
501 if(_start<0 || _start>=arr->getNumberOfTuples())
503 std::ostringstream oss; oss << "MEDFileFieldPerMeshPerTypePerDisc::loadBigArray : Invalid start ("<< _start << ") regarding admissible range of allocated array [0," << arr->getNumberOfTuples() << ") !";
504 throw INTERP_KERNEL::Exception(oss.str().c_str());
506 if(_end<0 || _end>arr->getNumberOfTuples())
508 std::ostringstream oss; oss << "MEDFileFieldPerMeshPerTypePerDisc::loadBigArray : Invalid start ("<< _start << ") regarding admissible range of allocated array [0," << arr->getNumberOfTuples() << "] !";
509 throw INTERP_KERNEL::Exception(oss.str().c_str());
512 INTERP_KERNEL::AutoPtr<char> locname=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
513 med_int nbValsInFile=MEDfieldnValueWithProfileByName(fid,fieldName.c_str(),iteration,order,menti,mgeoti,_profile.c_str(),MED_COMPACT_PFLMODE,&tmp1,locname,&nbi);
514 int nbOfCompo=arr->getNumberOfComponents();
515 if(_end-_start!=nbValsInFile*nbi)
517 std::ostringstream oss; oss << "MEDFileFieldPerMeshPerTypePerDisc::loadBigArray : The number of tuples to read is " << nbValsInFile << "*" << nbi << " (nb integration points) ! But in data structure it values " << _end-_start << " is expected !";
518 throw INTERP_KERNEL::Exception(oss.str().c_str());
520 DataArrayDouble *arrD=dynamic_cast<DataArrayDouble *>(arr);
523 double *startFeeding=arrD->getPointer()+_start*nbOfCompo;
524 MEDfieldValueWithProfileRd(fid,fieldName.c_str(),iteration,order,menti,mgeoti,MED_COMPACT_PFLMODE,
525 _profile.c_str(),MED_FULL_INTERLACE,MED_ALL_CONSTITUENT,reinterpret_cast<unsigned char*>(startFeeding));
528 DataArrayInt *arrI=dynamic_cast<DataArrayInt *>(arr);
531 int *startFeeding=arrI->getPointer()+_start*nbOfCompo;
532 MEDfieldValueWithProfileRd(fid,fieldName.c_str(),iteration,order,menti,mgeoti,MED_COMPACT_PFLMODE,
533 _profile.c_str(),MED_FULL_INTERLACE,MED_ALL_CONSTITUENT,reinterpret_cast<unsigned char*>(startFeeding));
536 throw INTERP_KERNEL::Exception("Error on array reading ! Unrecognized type of field ! Should be in FLOAT64 or INT32 !");
540 * Set a \c this->_start **and** \c this->_end keeping the same delta between the two.
542 void MEDFileFieldPerMeshPerTypePerDisc::setNewStart(int newValueOfStart)
544 int delta=_end-_start;
545 _start=newValueOfStart;
549 int MEDFileFieldPerMeshPerTypePerDisc::getIteration() const
551 return _father->getIteration();
554 int MEDFileFieldPerMeshPerTypePerDisc::getOrder() const
556 return _father->getOrder();
559 double MEDFileFieldPerMeshPerTypePerDisc::getTime() const
561 return _father->getTime();
564 std::string MEDFileFieldPerMeshPerTypePerDisc::getMeshName() const
566 return _father->getMeshName();
569 void MEDFileFieldPerMeshPerTypePerDisc::simpleRepr(int bkOffset, std::ostream& oss, int id) const
571 const char startLine[]=" ## ";
572 std::string startLine2(bkOffset,' ');
573 startLine2+=startLine;
574 MEDCouplingFieldDiscretization *tmp=MEDCouplingFieldDiscretization::New(_type);
575 oss << startLine2 << "Localization #" << id << "." << std::endl;
576 oss << startLine2 << " Type=" << tmp->getRepr() << "." << std::endl;
578 oss << startLine2 << " This type discretization lies on profile : \"" << _profile << "\" and on the following localization : \"" << _localization << "\"." << std::endl;
579 oss << startLine2 << " This type discretization has " << _end-_start << " tuples (start=" << _start << ", end=" << _end << ")." << std::endl;
580 oss << startLine2 << " This type discretization has " << (_end-_start)/_nval << " integration points." << std::endl;
583 TypeOfField MEDFileFieldPerMeshPerTypePerDisc::getType() const
588 void MEDFileFieldPerMeshPerTypePerDisc::fillTypesOfFieldAvailable(std::set<TypeOfField>& types) const
593 void MEDFileFieldPerMeshPerTypePerDisc::setType(TypeOfField newType)
598 INTERP_KERNEL::NormalizedCellType MEDFileFieldPerMeshPerTypePerDisc::getGeoType() const
600 return _father->getGeoType();
603 int MEDFileFieldPerMeshPerTypePerDisc::getNumberOfComponents() const
605 return _father->getNumberOfComponents();
608 int MEDFileFieldPerMeshPerTypePerDisc::getNumberOfTuples() const
613 DataArray *MEDFileFieldPerMeshPerTypePerDisc::getOrCreateAndGetArray()
615 return _father->getOrCreateAndGetArray();
618 const DataArray *MEDFileFieldPerMeshPerTypePerDisc::getOrCreateAndGetArray() const
620 const MEDFileFieldPerMeshPerType *fath=_father;
621 return fath->getOrCreateAndGetArray();
624 const std::vector<std::string>& MEDFileFieldPerMeshPerTypePerDisc::getInfo() const
626 return _father->getInfo();
629 std::string MEDFileFieldPerMeshPerTypePerDisc::getProfile() const
634 void MEDFileFieldPerMeshPerTypePerDisc::setProfile(const std::string& newPflName)
639 std::string MEDFileFieldPerMeshPerTypePerDisc::getLocalization() const
641 return _localization;
644 void MEDFileFieldPerMeshPerTypePerDisc::setLocalization(const std::string& newLocName)
646 _localization=newLocName;
649 void MEDFileFieldPerMeshPerTypePerDisc::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
651 for(std::vector< std::pair<std::vector<std::string>, std::string > >::const_iterator it2=mapOfModif.begin();it2!=mapOfModif.end();it2++)
653 if(std::find((*it2).first.begin(),(*it2).first.end(),_profile)!=(*it2).first.end())
655 _profile=(*it2).second;
661 void MEDFileFieldPerMeshPerTypePerDisc::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
663 for(std::vector< std::pair<std::vector<std::string>, std::string > >::const_iterator it2=mapOfModif.begin();it2!=mapOfModif.end();it2++)
665 if(std::find((*it2).first.begin(),(*it2).first.end(),_localization)!=(*it2).first.end())
667 _localization=(*it2).second;
673 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
677 dads.push_back(std::pair<int,int>(_start,_end));
678 geoTypes.push_back(getGeoType());
683 pfls.push_back(glob->getProfile(_profile.c_str()));
685 if(_localization.empty())
689 locs.push_back(glob->getLocalizationId(_localization.c_str()));
693 void MEDFileFieldPerMeshPerTypePerDisc::fillValues(int discId, int& startEntryId, std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
695 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));
699 void MEDFileFieldPerMeshPerTypePerDisc::writeLL(med_idt fid, const MEDFileFieldNameScope& nasc) const
701 TypeOfField type=getType();
702 INTERP_KERNEL::NormalizedCellType geoType=getGeoType();
703 med_geometry_type mgeoti;
704 med_entity_type menti=MEDFileFieldPerMeshPerType::ConvertIntoMEDFileType(type,geoType,mgeoti);
705 const DataArray *arr=getOrCreateAndGetArray();
707 throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::writeLL : no array set !");
708 const DataArrayDouble *arrD=dynamic_cast<const DataArrayDouble *>(arr);
709 const DataArrayInt *arrI=dynamic_cast<const DataArrayInt *>(arr);
710 const unsigned char *locToWrite=0;
712 locToWrite=reinterpret_cast<const unsigned char *>(arrD->getConstPointer()+_start*arr->getNumberOfComponents());
714 locToWrite=reinterpret_cast<const unsigned char *>(arrI->getConstPointer()+_start*arr->getNumberOfComponents());
716 throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::writeLL : not recognized type of values ! Supported are FLOAT64 and INT32 !");
717 MEDfieldValueWithProfileWr(fid,nasc.getName().c_str(),getIteration(),getOrder(),getTime(),menti,mgeoti,
718 MED_COMPACT_PFLMODE,_profile.c_str(),_localization.c_str(),MED_FULL_INTERLACE,MED_ALL_CONSTITUENT,_nval,
722 void MEDFileFieldPerMeshPerTypePerDisc::getCoarseData(TypeOfField& type, std::pair<int,int>& dad, std::string& pfl, std::string& loc) const
727 dad.first=_start; dad.second=_end;
731 * \param [in] codeOfMesh is of format returned by MEDCouplingUMesh::getDistributionOfTypes. And for each *i* oldCode[3*i+2] gives the position (MEDFileUMesh::PutInThirdComponentOfCodeOffset).
732 * This code corresponds to the distribution of types in the corresponding mesh.
733 * \param [out] ptToFill memory zone where the output will be stored.
734 * \return the size of data pushed into output param \a ptToFill
736 int MEDFileFieldPerMeshPerTypePerDisc::fillEltIdsFromCode(int offset, const std::vector<int>& codeOfMesh, const MEDFileFieldGlobsReal& glob, int *ptToFill) const
739 std::ostringstream oss;
740 std::size_t nbOfType=codeOfMesh.size()/3;
742 for(std::size_t i=0;i<nbOfType && found==-1;i++)
743 if(getGeoType()==(INTERP_KERNEL::NormalizedCellType)codeOfMesh[3*i])
747 const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(getGeoType());
748 oss << "MEDFileFieldPerMeshPerTypePerDisc::fillEltIdsFromCode : not found geometric type " << cm.getRepr() << " in the referenced mesh of field !";
749 throw INTERP_KERNEL::Exception(oss.str().c_str());
754 if(_nval!=codeOfMesh[3*found+1])
756 const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(getGeoType());
757 oss << "MEDFileFieldPerMeshPerTypePerDisc::fillEltIdsFromCode : for geometric type " << cm.getRepr() << " number of elt ids in mesh is equal to " << _nval;
758 oss << " whereas mesh has " << codeOfMesh[3*found+1] << " for this geometric type !";
759 throw INTERP_KERNEL::Exception(oss.str().c_str());
761 for(int ii=codeOfMesh[3*found+2];ii<codeOfMesh[3*found+2]+_nval;ii++)
766 const DataArrayInt *pfl=glob.getProfile(_profile.c_str());
767 if(pfl->getNumberOfTuples()!=_nval)
769 const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(getGeoType());
770 oss << "MEDFileFieldPerMeshPerTypePerDisc::fillEltIdsFromCode : for geometric type " << cm.getRepr() << ", field is defined on profile \"" << _profile << "\" and size of profile is ";
772 oss << pfl->getNumberOfTuples() << " whereas the number of ids is set to " << _nval << " for this geometric type !";
773 throw INTERP_KERNEL::Exception(oss.str().c_str());
775 int offset2=codeOfMesh[3*found+2];
776 for(const int *pflId=pfl->begin();pflId!=pfl->end();pflId++)
778 if(*pflId<codeOfMesh[3*found+1])
779 *work++=offset2+*pflId;
785 int MEDFileFieldPerMeshPerTypePerDisc::fillTupleIds(int *ptToFill) const
787 for(int i=_start;i<_end;i++)
792 int MEDFileFieldPerMeshPerTypePerDisc::ConvertType(TypeOfField type, int locId)
803 throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::ConvertType : not managed type of field !");
807 std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> > MEDFileFieldPerMeshPerTypePerDisc::SplitPerDiscretization(const std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>& entries)
810 std::map<std::pair<std::string,TypeOfField>,int> m;
811 std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> > ret;
812 for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=entries.begin();it!=entries.end();it++)
813 if(m.find(std::pair<std::string,TypeOfField>((*it)->getLocalization(),(*it)->getType()))==m.end())
814 m[std::pair<std::string,TypeOfField>((*it)->getLocalization(),(*it)->getType())]=id++;
816 for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=entries.begin();it!=entries.end();it++)
817 ret[m[std::pair<std::string,TypeOfField>((*it)->getLocalization(),(*it)->getType())]].push_back(*it);
822 * - \c this->_loc_id mutable attribute is used for elt id in mesh offsets.
824 * \param [in] offset the offset id used to take into account that \a result is not compulsary empty in input
825 * \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.
826 * \param [in] explicitIdsInMesh ids in mesh of the considered chunk.
827 * \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)
828 * \param [in,out] glob if necessary by the method, new profiles can be added to it
829 * \param [in,out] arr after the call of this method \a arr is renumbered to be compliant with added entries to \a result.
830 * \param [out] result All new entries will be appended on it.
831 * \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 !)
833 bool MEDFileFieldPerMeshPerTypePerDisc::RenumberChunks(int offset, const std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>& entriesOnSameDisc,
834 const DataArrayInt *explicitIdsInMesh,
835 const std::vector<int>& newCode,
836 MEDFileFieldGlobsReal& glob, DataArrayDouble *arr,
837 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >& result)
839 if(entriesOnSameDisc.empty())
841 TypeOfField type=entriesOnSameDisc[0]->getType();
842 int szEntities=0,szTuples=0;
843 for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=entriesOnSameDisc.begin();it!=entriesOnSameDisc.end();it++)
844 { szEntities+=(*it)->_nval; szTuples+=(*it)->_end-(*it)->_start; }
845 int nbi=szTuples/szEntities;
846 if(szTuples%szEntities!=0)
847 throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::RenumberChunks : internal error the splitting into same dicretization failed !");
848 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> renumTuples=DataArrayInt::New(); renumTuples->alloc(szTuples,1);
849 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ranges=MEDCouplingUMesh::ComputeRangesFromTypeDistribution(newCode);
850 std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > newGeoTypesPerChunk(entriesOnSameDisc.size());
851 std::vector< const DataArrayInt * > newGeoTypesPerChunk2(entriesOnSameDisc.size());
852 std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > newGeoTypesPerChunk_bis(entriesOnSameDisc.size());
853 std::vector< const DataArrayInt * > newGeoTypesPerChunk3(entriesOnSameDisc.size());
854 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> newGeoTypesPerChunk4=DataArrayInt::New(); newGeoTypesPerChunk4->alloc(szEntities,nbi);
856 for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=entriesOnSameDisc.begin();it!=entriesOnSameDisc.end();it++,id++)
858 int startOfEltIdOfChunk=(*it)->_start;
859 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> newEltIds=explicitIdsInMesh->substr(startOfEltIdOfChunk,startOfEltIdOfChunk+(*it)->_nval);
860 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> rangeIdsForChunk=newEltIds->findRangeIdForEachTuple(ranges);
861 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> idsInRrangeForChunk=newEltIds->findIdInRangeForEachTuple(ranges);
863 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmp=rangeIdsForChunk->duplicateEachTupleNTimes(nbi); rangeIdsForChunk->rearrange(nbi);
864 newGeoTypesPerChunk4->setPartOfValues1(tmp,(*it)->_tmp_work1-offset,(*it)->_tmp_work1+(*it)->_nval*nbi-offset,1,0,nbi,1);
866 newGeoTypesPerChunk[id]=rangeIdsForChunk; newGeoTypesPerChunk2[id]=rangeIdsForChunk;
867 newGeoTypesPerChunk_bis[id]=idsInRrangeForChunk; newGeoTypesPerChunk3[id]=idsInRrangeForChunk;
869 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> newGeoTypesEltIdsAllGather=DataArrayInt::Aggregate(newGeoTypesPerChunk2); newGeoTypesPerChunk.clear(); newGeoTypesPerChunk2.clear();
870 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> newGeoTypesEltIdsAllGather2=DataArrayInt::Aggregate(newGeoTypesPerChunk3); newGeoTypesPerChunk_bis.clear(); newGeoTypesPerChunk3.clear();
871 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> diffVals=newGeoTypesEltIdsAllGather->getDifferentValues();
872 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> renumEltIds=newGeoTypesEltIdsAllGather->buildPermArrPerLevel();
874 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> renumTupleIds=newGeoTypesPerChunk4->buildPermArrPerLevel();
876 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arrPart=arr->substr(offset,offset+szTuples);
877 arrPart->renumberInPlace(renumTupleIds->begin());
878 arr->setPartOfValues1(arrPart,offset,offset+szTuples,1,0,arrPart->getNumberOfComponents(),1);
880 const int *idIt=diffVals->begin();
881 std::list<const MEDFileFieldPerMeshPerTypePerDisc *> li(entriesOnSameDisc.begin(),entriesOnSameDisc.end());
883 for(int i=0;i<diffVals->getNumberOfTuples();i++,idIt++)
885 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ids=newGeoTypesEltIdsAllGather->getIdsEqual(*idIt);
886 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> subIds=newGeoTypesEltIdsAllGather2->selectByTupleId(ids->begin(),ids->end());
887 int nbEntityElts=subIds->getNumberOfTuples();
889 MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> eltToAdd=MEDFileFieldPerMeshPerTypePerDisc::
890 NewObjectOnSameDiscThanPool(type,(INTERP_KERNEL::NormalizedCellType)newCode[3*(*idIt)],subIds,!subIds->isIdentity() || nbEntityElts!=newCode[3*(*idIt)+1],nbi,
894 result.push_back(eltToAdd);
895 offset2+=nbEntityElts*nbi;
897 ret=ret || li.empty();
902 * \param [in] typeF type of field of new chunk
903 * \param [in] geoType the geometric type of the chunk
904 * \param [in] idsOfMeshElt the entity ids of mesh (cells or nodes) of the new chunk.
905 * \param [in] isPfl specifies if a profile is requested regarding size of \a idsOfMeshElt and the number of such entities regarding underlying mesh.
906 * \param [in] nbi number of integration points
907 * \param [in] offset The offset in the **global array of data**.
908 * \param [in,out] entriesOnSameDisc the pool **on the same discretization** inside which it will be attempted to find an existing entry corresponding exactly
909 * to the new chunk to create.
910 * \param [in,out] glob the global shared info that will be requested for existing profiles or to append a new profile if needed.
911 * \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
912 * and corresponding entry erased from \a entriesOnSameDisc.
913 * \return a newly allocated chunk
915 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerTypePerDisc::NewObjectOnSameDiscThanPool(TypeOfField typeF, INTERP_KERNEL::NormalizedCellType geoType, DataArrayInt *idsOfMeshElt,
916 bool isPfl, int nbi, int offset,
917 std::list< const MEDFileFieldPerMeshPerTypePerDisc *>& entriesOnSameDisc,
918 MEDFileFieldGlobsReal& glob,
919 bool ¬InExisting) throw(INTERP_KERNEL::Exception)
921 int nbMeshEntities=idsOfMeshElt->getNumberOfTuples();
922 std::list< const MEDFileFieldPerMeshPerTypePerDisc *>::iterator it=entriesOnSameDisc.begin();
923 for(;it!=entriesOnSameDisc.end();it++)
925 if(((INTERP_KERNEL::NormalizedCellType)(*it)->_loc_id)==geoType && (*it)->_nval==nbMeshEntities)
929 if((*it)->_profile.empty())
932 if(!(*it)->_profile.empty())
934 const DataArrayInt *pfl=glob.getProfile((*it)->_profile.c_str());
935 if(pfl->isEqualWithoutConsideringStr(*idsOfMeshElt))
941 if(it==entriesOnSameDisc.end())
944 MEDFileFieldPerMeshPerTypePerDisc *ret=new MEDFileFieldPerMeshPerTypePerDisc;
946 ret->_loc_id=(int)geoType;
947 ret->_nval=nbMeshEntities;
949 ret->_end=ret->_start+ret->_nval*nbi;
952 idsOfMeshElt->setName(glob.createNewNameOfPfl().c_str());
953 glob.appendProfile(idsOfMeshElt);
954 ret->_profile=idsOfMeshElt->getName();
956 //tony treatment of localization
962 MEDFileFieldPerMeshPerTypePerDisc *ret=MEDFileFieldPerMeshPerTypePerDisc::New(*(*it));
963 ret->_loc_id=(int)geoType;
964 ret->setNewStart(offset);
965 entriesOnSameDisc.erase(it);
971 MEDFileFieldPerMeshPerType *MEDFileFieldPerMeshPerType::NewOnRead(med_idt fid, MEDFileFieldPerMesh *fath, TypeOfField type, INTERP_KERNEL::NormalizedCellType geoType, const MEDFileFieldNameScope& nasc)
973 return new MEDFileFieldPerMeshPerType(fid,fath,type,geoType,nasc);
976 MEDFileFieldPerMeshPerType *MEDFileFieldPerMeshPerType::New(MEDFileFieldPerMesh *fath, INTERP_KERNEL::NormalizedCellType geoType)
978 return new MEDFileFieldPerMeshPerType(fath,geoType);
981 std::size_t MEDFileFieldPerMeshPerType::getHeapMemorySizeWithoutChildren() const
983 return _field_pm_pt_pd.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc>);
986 std::vector<const BigMemoryObject *> MEDFileFieldPerMeshPerType::getDirectChildren() const
988 std::vector<const BigMemoryObject *> ret;
989 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
991 const MEDFileFieldPerMeshPerTypePerDisc *cur(*it);
998 MEDFileFieldPerMeshPerType *MEDFileFieldPerMeshPerType::deepCpy(MEDFileFieldPerMesh *father) const
1000 MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerType> ret=new MEDFileFieldPerMeshPerType(*this);
1001 ret->_father=father;
1003 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++,i++)
1005 if((const MEDFileFieldPerMeshPerTypePerDisc *)*it)
1006 ret->_field_pm_pt_pd[i]=(*it)->deepCpy((MEDFileFieldPerMeshPerType *)ret);
1011 void MEDFileFieldPerMeshPerType::assignFieldNoProfile(int& start, int offset, int nbOfCells, const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc)
1013 std::vector<int> pos=addNewEntryIfNecessary(field,offset,nbOfCells);
1014 for(std::vector<int>::const_iterator it=pos.begin();it!=pos.end();it++)
1015 _field_pm_pt_pd[*it]->assignFieldNoProfile(start,offset,nbOfCells,field,arr,glob,nasc);
1019 * This method is the most general one. No optimization is done here.
1020 * \param [in] multiTypePfl is the end user profile specified in high level API
1021 * \param [in] idsInPfl is the selection into the \a multiTypePfl whole profile that corresponds to the current geometric type.
1022 * \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.
1023 * \b WARNING if not null the MED file profile can be subdivided again in case of Gauss points.
1024 * \param [in] nbOfEltsInWholeMesh nb of elts of type \a this->_geo_type in \b WHOLE mesh
1025 * \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.
1027 void MEDFileFieldPerMeshPerType::assignFieldProfile(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)
1029 std::vector<int> pos=addNewEntryIfNecessary(field,idsInPfl);
1030 for(std::vector<int>::const_iterator it=pos.begin();it!=pos.end();it++)
1031 _field_pm_pt_pd[*it]->assignFieldProfile(start,multiTypePfl,idsInPfl,locIds,nbOfEltsInWholeMesh,field,arr,mesh,glob,nasc);
1034 void MEDFileFieldPerMeshPerType::assignNodeFieldNoProfile(int& start, const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob)
1036 _field_pm_pt_pd.resize(1);
1037 _field_pm_pt_pd[0]=MEDFileFieldPerMeshPerTypePerDisc::New(this,ON_NODES,-3);
1038 _field_pm_pt_pd[0]->assignNodeFieldNoProfile(start,field,arr,glob);
1041 void MEDFileFieldPerMeshPerType::assignNodeFieldProfile(int& start, const DataArrayInt *pfl, const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc)
1043 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> pfl2=pfl->deepCpy();
1044 if(!arr || !arr->isAllocated())
1045 throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerType::assignNodeFieldProfile : input array is null, or not allocated !");
1046 _field_pm_pt_pd.resize(1);
1047 _field_pm_pt_pd[0]=MEDFileFieldPerMeshPerTypePerDisc::New(this,ON_NODES,-3);
1048 _field_pm_pt_pd[0]->assignFieldProfile(start,pfl,pfl2,pfl2,-1,field,arr,0,glob,nasc);//mesh is not requested so 0 is send.
1051 std::vector<int> MEDFileFieldPerMeshPerType::addNewEntryIfNecessary(const MEDCouplingFieldDouble *field, int offset, int nbOfCells)
1053 TypeOfField type=field->getTypeOfField();
1054 if(type!=ON_GAUSS_PT)
1056 int locIdToFind=MEDFileFieldPerMeshPerTypePerDisc::ConvertType(type,0);
1057 int sz=_field_pm_pt_pd.size();
1059 for(int j=0;j<sz && !found;j++)
1061 if(_field_pm_pt_pd[j]->getLocId()==locIdToFind)
1063 _field_pm_pt_pd[j]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1069 _field_pm_pt_pd.resize(sz+1);
1070 _field_pm_pt_pd[sz]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1072 std::vector<int> ret(1,(int)sz);
1077 std::vector<int> ret2=addNewEntryIfNecessaryGauss(field,offset,nbOfCells);
1078 int sz2=ret2.size();
1079 std::vector<int> ret3(sz2);
1081 for(int i=0;i<sz2;i++)
1083 int sz=_field_pm_pt_pd.size();
1084 int locIdToFind=ret2[i];
1086 for(int j=0;j<sz && !found;j++)
1088 if(_field_pm_pt_pd[j]->getLocId()==locIdToFind)
1090 _field_pm_pt_pd[j]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1097 _field_pm_pt_pd.resize(sz+1);
1098 _field_pm_pt_pd[sz]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1106 std::vector<int> MEDFileFieldPerMeshPerType::addNewEntryIfNecessaryGauss(const MEDCouplingFieldDouble *field, int offset, int nbOfCells)
1108 const MEDCouplingFieldDiscretization *disc=field->getDiscretization();
1109 const MEDCouplingFieldDiscretizationGauss *disc2=dynamic_cast<const MEDCouplingFieldDiscretizationGauss *>(disc);
1111 throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : invalid call to this method ! Internal Error !");
1112 const DataArrayInt *da=disc2->getArrayOfDiscIds();
1114 throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss (no profile) : no localization ids per cell array available ! The input Gauss node field is maybe invalid !");
1115 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da2=da->selectByTupleId2(offset,offset+nbOfCells,1);
1116 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> retTmp=da2->getDifferentValues();
1117 if(retTmp->presenceOfValue(-1))
1118 throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : some cells have no dicretization description !");
1119 std::vector<int> ret(retTmp->begin(),retTmp->end());
1123 std::vector<int> MEDFileFieldPerMeshPerType::addNewEntryIfNecessary(const MEDCouplingFieldDouble *field, const DataArrayInt *subCells)
1125 TypeOfField type=field->getTypeOfField();
1126 if(type!=ON_GAUSS_PT)
1128 int locIdToFind=MEDFileFieldPerMeshPerTypePerDisc::ConvertType(type,0);
1129 int sz=_field_pm_pt_pd.size();
1131 for(int j=0;j<sz && !found;j++)
1133 if(_field_pm_pt_pd[j]->getLocId()==locIdToFind)
1135 _field_pm_pt_pd[j]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1141 _field_pm_pt_pd.resize(sz+1);
1142 _field_pm_pt_pd[sz]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1144 std::vector<int> ret(1,0);
1149 std::vector<int> ret2=addNewEntryIfNecessaryGauss(field,subCells);
1150 int sz2=ret2.size();
1151 std::vector<int> ret3(sz2);
1153 for(int i=0;i<sz2;i++)
1155 int sz=_field_pm_pt_pd.size();
1156 int locIdToFind=ret2[i];
1158 for(int j=0;j<sz && !found;j++)
1160 if(_field_pm_pt_pd[j]->getLocId()==locIdToFind)
1162 _field_pm_pt_pd[j]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1169 _field_pm_pt_pd.resize(sz+1);
1170 _field_pm_pt_pd[sz]=MEDFileFieldPerMeshPerTypePerDisc::New(this,type,locIdToFind);
1178 std::vector<int> MEDFileFieldPerMeshPerType::addNewEntryIfNecessaryGauss(const MEDCouplingFieldDouble *field, const DataArrayInt *subCells)
1180 const MEDCouplingFieldDiscretization *disc=field->getDiscretization();
1181 const MEDCouplingFieldDiscretizationGauss *disc2=dynamic_cast<const MEDCouplingFieldDiscretizationGauss *>(disc);
1183 throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : invalid call to this method ! Internal Error !");
1184 const DataArrayInt *da=disc2->getArrayOfDiscIds();
1186 throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : no localization ids per cell array available ! The input Gauss node field is maybe invalid !");
1187 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da2=da->selectByTupleIdSafe(subCells->getConstPointer(),subCells->getConstPointer()+subCells->getNumberOfTuples());
1188 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> retTmp=da2->getDifferentValues();
1189 if(retTmp->presenceOfValue(-1))
1190 throw INTERP_KERNEL::Exception("addNewEntryIfNecessaryGauss : some cells have no dicretization description !");
1191 std::vector<int> ret(retTmp->begin(),retTmp->end());
1195 const MEDFileFieldPerMesh *MEDFileFieldPerMeshPerType::getFather() const
1200 void MEDFileFieldPerMeshPerType::getDimension(int& dim) const
1202 const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1203 int curDim=(int)cm.getDimension();
1204 dim=std::max(dim,curDim);
1207 void MEDFileFieldPerMeshPerType::fillTypesOfFieldAvailable(std::set<TypeOfField>& types) const
1209 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1211 (*it)->fillTypesOfFieldAvailable(types);
1215 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
1217 int sz=_field_pm_pt_pd.size();
1218 dads.resize(sz); types.resize(sz); pfls.resize(sz); locs.resize(sz);
1219 for(int i=0;i<sz;i++)
1221 _field_pm_pt_pd[i]->getCoarseData(types[i],dads[i],pfls[i],locs[i]);
1225 int MEDFileFieldPerMeshPerType::getIteration() const
1227 return _father->getIteration();
1230 int MEDFileFieldPerMeshPerType::getOrder() const
1232 return _father->getOrder();
1235 double MEDFileFieldPerMeshPerType::getTime() const
1237 return _father->getTime();
1240 std::string MEDFileFieldPerMeshPerType::getMeshName() const
1242 return _father->getMeshName();
1245 void MEDFileFieldPerMeshPerType::simpleRepr(int bkOffset, std::ostream& oss, int id) const
1247 const char startLine[]=" ## ";
1248 std::string startLine2(bkOffset,' ');
1249 std::string startLine3(startLine2);
1250 startLine3+=startLine;
1251 if(_geo_type!=INTERP_KERNEL::NORM_ERROR)
1253 const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1254 oss << startLine3 << "Entry geometry type #" << id << " is lying on geometry types " << cm.getRepr() << "." << std::endl;
1257 oss << startLine3 << "Entry geometry type #" << id << " is lying on NODES." << std::endl;
1258 oss << startLine3 << "Entry is defined on " << _field_pm_pt_pd.size() << " localizations." << std::endl;
1260 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++,i++)
1262 const MEDFileFieldPerMeshPerTypePerDisc *cur=(*it);
1264 cur->simpleRepr(bkOffset,oss,i);
1267 oss << startLine2 << " ## " << "Localization #" << i << " is empty !" << std::endl;
1272 void MEDFileFieldPerMeshPerType::getSizes(int& globalSz, int& nbOfEntries) const
1274 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1276 globalSz+=(*it)->getNumberOfTuples();
1278 nbOfEntries+=(int)_field_pm_pt_pd.size();
1281 INTERP_KERNEL::NormalizedCellType MEDFileFieldPerMeshPerType::getGeoType() const
1287 int MEDFileFieldPerMeshPerType::getNumberOfComponents() const
1289 return _father->getNumberOfComponents();
1292 DataArray *MEDFileFieldPerMeshPerType::getOrCreateAndGetArray()
1294 return _father->getOrCreateAndGetArray();
1297 const DataArray *MEDFileFieldPerMeshPerType::getOrCreateAndGetArray() const
1299 const MEDFileFieldPerMesh *fath=_father;
1300 return fath->getOrCreateAndGetArray();
1303 const std::vector<std::string>& MEDFileFieldPerMeshPerType::getInfo() const
1305 return _father->getInfo();
1308 std::vector<std::string> MEDFileFieldPerMeshPerType::getPflsReallyUsed() const
1310 std::vector<std::string> ret;
1311 std::set<std::string> ret2;
1312 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1314 std::string tmp=(*it1)->getProfile();
1316 if(ret2.find(tmp)==ret2.end())
1325 std::vector<std::string> MEDFileFieldPerMeshPerType::getLocsReallyUsed() const
1327 std::vector<std::string> ret;
1328 std::set<std::string> ret2;
1329 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1331 std::string tmp=(*it1)->getLocalization();
1332 if(!tmp.empty() && tmp!=MED_GAUSS_ELNO)
1333 if(ret2.find(tmp)==ret2.end())
1342 std::vector<std::string> MEDFileFieldPerMeshPerType::getPflsReallyUsedMulti() const
1344 std::vector<std::string> ret;
1345 std::set<std::string> ret2;
1346 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1348 std::string tmp=(*it1)->getProfile();
1355 std::vector<std::string> MEDFileFieldPerMeshPerType::getLocsReallyUsedMulti() const
1357 std::vector<std::string> ret;
1358 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1360 std::string tmp=(*it1)->getLocalization();
1361 if(!tmp.empty() && tmp!=MED_GAUSS_ELNO)
1367 void MEDFileFieldPerMeshPerType::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
1369 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1370 (*it1)->changePflsRefsNamesGen(mapOfModif);
1373 void MEDFileFieldPerMeshPerType::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
1375 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it1=_field_pm_pt_pd.begin();it1!=_field_pm_pt_pd.end();it1++)
1376 (*it1)->changeLocsRefsNamesGen(mapOfModif);
1379 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerType::getLeafGivenLocId(int locId)
1381 if(_field_pm_pt_pd.empty())
1383 const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1384 std::ostringstream oss; oss << "MEDFileFieldPerMeshPerType::getLeafGivenLocId : no localizations for geotype \"" << cm.getRepr() << "\" !";
1385 throw INTERP_KERNEL::Exception(oss.str().c_str());
1387 if(locId>=0 && locId<(int)_field_pm_pt_pd.size())
1388 return _field_pm_pt_pd[locId];
1389 const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1390 std::ostringstream oss2; oss2 << "MEDFileFieldPerMeshPerType::getLeafGivenLocId : no such locId available (" << locId;
1391 oss2 << ") for geometric type \"" << cm.getRepr() << "\" It should be in [0," << _field_pm_pt_pd.size() << ") !";
1392 throw INTERP_KERNEL::Exception(oss2.str().c_str());
1393 return static_cast<MEDFileFieldPerMeshPerTypePerDisc*>(0);
1396 const MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMeshPerType::getLeafGivenLocId(int locId) const
1398 if(_field_pm_pt_pd.empty())
1400 const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1401 std::ostringstream oss; oss << "MEDFileFieldPerMeshPerType::getLeafGivenLocId : no localizations for geotype \"" << cm.getRepr() << "\" !";
1402 throw INTERP_KERNEL::Exception(oss.str().c_str());
1404 if(locId>=0 && locId<(int)_field_pm_pt_pd.size())
1405 return _field_pm_pt_pd[locId];
1406 const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1407 std::ostringstream oss2; oss2 << "MEDFileFieldPerMeshPerType::getLeafGivenLocId : no such locId available (" << locId;
1408 oss2 << ") for geometric type \"" << cm.getRepr() << "\" It should be in [0," << _field_pm_pt_pd.size() << ") !";
1409 throw INTERP_KERNEL::Exception(oss2.str().c_str());
1410 return static_cast<const MEDFileFieldPerMeshPerTypePerDisc*>(0);
1413 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
1415 if(_geo_type!=INTERP_KERNEL::NORM_ERROR)
1417 const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_geo_type);
1418 if(meshDim!=(int)cm.getDimension())
1421 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1422 (*it)->getFieldAtLevel(type,glob,dads,pfls,locs,geoTypes);
1425 void MEDFileFieldPerMeshPerType::fillValues(int& startEntryId, std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
1428 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++,i++)
1430 (*it)->fillValues(i,startEntryId,entries);
1434 void MEDFileFieldPerMeshPerType::setLeaves(const std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerTypePerDisc > >& leaves)
1436 _field_pm_pt_pd=leaves;
1437 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1438 (*it)->setFather(this);
1442 * \param [in,out] globalNum a global numbering counter for the renumbering.
1443 * \param [out] its - list of pair (start,stop) kept
1444 * \return bool - false if the type of field \a tof is not contained in \a this.
1446 bool MEDFileFieldPerMeshPerType::keepOnlySpatialDiscretization(TypeOfField tof, int &globalNum, std::vector< std::pair<int,int> >& its)
1449 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> > newPmPtPd;
1450 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1451 if((*it)->getType()==tof)
1453 newPmPtPd.push_back(*it);
1454 std::pair<int,int> bgEnd; bgEnd.first=(*it)->getStart(); bgEnd.second=(*it)->getEnd();
1455 (*it)->setNewStart(globalNum);
1456 globalNum=(*it)->getEnd();
1457 its.push_back(bgEnd);
1461 _field_pm_pt_pd=newPmPtPd;
1465 MEDFileFieldPerMeshPerType::MEDFileFieldPerMeshPerType(MEDFileFieldPerMesh *fath, INTERP_KERNEL::NormalizedCellType geoType):_father(fath),_geo_type(geoType)
1469 MEDFileFieldPerMeshPerType::MEDFileFieldPerMeshPerType(med_idt fid, MEDFileFieldPerMesh *fath, TypeOfField type, INTERP_KERNEL::NormalizedCellType geoType, const MEDFileFieldNameScope& nasc):_father(fath),_geo_type(geoType)
1471 INTERP_KERNEL::AutoPtr<char> pflName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
1472 INTERP_KERNEL::AutoPtr<char> locName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
1473 med_geometry_type mgeoti;
1474 med_entity_type menti;
1475 menti=ConvertIntoMEDFileType(type,geoType,mgeoti);
1476 int nbProfiles=MEDfieldnProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),menti,mgeoti,pflName,locName);
1477 _field_pm_pt_pd.resize(nbProfiles);
1478 for(int i=0;i<nbProfiles;i++)
1480 _field_pm_pt_pd[i]=MEDFileFieldPerMeshPerTypePerDisc::NewOnRead(this,type,i+1);
1484 int nbProfiles2=MEDfieldnProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_NODE_ELEMENT,mgeoti,pflName,locName);
1485 for(int i=0;i<nbProfiles2;i++)
1486 _field_pm_pt_pd.push_back(MEDFileFieldPerMeshPerTypePerDisc::NewOnRead(this,ON_GAUSS_NE,i+1));
1490 void MEDFileFieldPerMeshPerType::loadOnlyStructureOfDataRecursively(med_idt fid, int &start, const MEDFileFieldNameScope& nasc)
1492 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1493 (*it)->loadOnlyStructureOfDataRecursively(fid,start,nasc);
1496 void MEDFileFieldPerMeshPerType::loadBigArraysRecursively(med_idt fid, const MEDFileFieldNameScope& nasc)
1498 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1499 (*it)->loadBigArray(fid,nasc);
1502 void MEDFileFieldPerMeshPerType::writeLL(med_idt fid, const MEDFileFieldNameScope& nasc) const
1504 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> >::const_iterator it=_field_pm_pt_pd.begin();it!=_field_pm_pt_pd.end();it++)
1506 (*it)->copyOptionsFrom(*this);
1507 (*it)->writeLL(fid,nasc);
1511 med_entity_type MEDFileFieldPerMeshPerType::ConvertIntoMEDFileType(TypeOfField ikType, INTERP_KERNEL::NormalizedCellType ikGeoType, med_geometry_type& medfGeoType)
1516 medfGeoType=typmai3[(int)ikGeoType];
1519 medfGeoType=MED_NONE;
1522 medfGeoType=typmai3[(int)ikGeoType];
1523 return MED_NODE_ELEMENT;
1525 medfGeoType=typmai3[(int)ikGeoType];
1528 throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerType::ConvertIntoMEDFileType : unexpected entity type ! internal error");
1530 return MED_UNDEF_ENTITY_TYPE;
1533 MEDFileFieldPerMesh *MEDFileFieldPerMesh::NewOnRead(med_idt fid, MEDFileAnyTypeField1TSWithoutSDA *fath, int meshCsit, int meshIteration, int meshOrder, const MEDFileFieldNameScope& nasc)
1535 return new MEDFileFieldPerMesh(fid,fath,meshCsit,meshIteration,meshOrder,nasc);
1538 MEDFileFieldPerMesh *MEDFileFieldPerMesh::New(MEDFileAnyTypeField1TSWithoutSDA *fath, const MEDCouplingMesh *mesh)
1540 return new MEDFileFieldPerMesh(fath,mesh);
1543 std::size_t MEDFileFieldPerMesh::getHeapMemorySizeWithoutChildren() const
1545 return _mesh_name.capacity()+_field_pm_pt.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType >);
1548 std::vector<const BigMemoryObject *> MEDFileFieldPerMesh::getDirectChildren() const
1550 std::vector<const BigMemoryObject *> ret;
1551 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1553 const MEDFileFieldPerMeshPerType *cur(*it);
1560 MEDFileFieldPerMesh *MEDFileFieldPerMesh::deepCpy(MEDFileAnyTypeField1TSWithoutSDA *father) const
1562 MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > ret=new MEDFileFieldPerMesh(*this);
1563 ret->_father=father;
1565 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++,i++)
1567 if((const MEDFileFieldPerMeshPerType *)*it)
1568 ret->_field_pm_pt[i]=(*it)->deepCpy((MEDFileFieldPerMesh *)(ret));
1573 void MEDFileFieldPerMesh::simpleRepr(int bkOffset, std::ostream& oss, int id) const
1575 std::string startLine(bkOffset,' ');
1576 oss << startLine << "## Field part (" << id << ") lying on mesh \"" << _mesh_name << "\", Mesh iteration=" << _mesh_iteration << ". Mesh order=" << _mesh_order << "." << std::endl;
1577 oss << startLine << "## Field is defined on " << _field_pm_pt.size() << " types." << std::endl;
1579 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++,i++)
1581 const MEDFileFieldPerMeshPerType *cur=*it;
1583 cur->simpleRepr(bkOffset,oss,i);
1586 oss << startLine << " ## Entry geometry type #" << i << " is empty !" << std::endl;
1591 void MEDFileFieldPerMesh::copyTinyInfoFrom(const MEDCouplingMesh *mesh)
1593 _mesh_name=mesh->getName();
1594 mesh->getTime(_mesh_iteration,_mesh_order);
1597 void MEDFileFieldPerMesh::assignFieldNoProfileNoRenum(int& start, const std::vector<int>& code, const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc)
1599 int nbOfTypes=code.size()/3;
1601 for(int i=0;i<nbOfTypes;i++)
1603 INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)code[3*i];
1604 int nbOfCells=code[3*i+1];
1605 int pos=addNewEntryIfNecessary(type);
1606 _field_pm_pt[pos]->assignFieldNoProfile(start,offset,nbOfCells,field,arr,glob,nasc);
1612 * This method is the most general one. No optimization is done here.
1613 * \param [in] multiTypePfl is the end user profile specified in high level API
1614 * \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].
1615 * \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.
1616 * \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.
1617 * \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.
1618 * \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.
1620 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)
1622 int nbOfTypes=code.size()/3;
1623 for(int i=0;i<nbOfTypes;i++)
1625 INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)code[3*i];
1626 int pos=addNewEntryIfNecessary(type);
1627 DataArrayInt *pfl=0;
1629 pfl=idsPerType[code[3*i+2]];
1630 int nbOfTupes2=code2.size()/3;
1632 for(;found<nbOfTupes2;found++)
1633 if(code[3*i]==code2[3*found])
1635 if(found==nbOfTupes2)
1636 throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::assignFieldProfile : internal problem ! Should never happen ! Please report bug to anthony.geay@cea.fr !");
1637 _field_pm_pt[pos]->assignFieldProfile(start,multiTypePfl,idsInPflPerType[i],pfl,code2[3*found+1],field,arr,mesh,glob,nasc);
1641 void MEDFileFieldPerMesh::assignNodeFieldNoProfile(int& start, const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob)
1643 int pos=addNewEntryIfNecessary(INTERP_KERNEL::NORM_ERROR);
1644 _field_pm_pt[pos]->assignNodeFieldNoProfile(start,field,arr,glob);
1647 void MEDFileFieldPerMesh::assignNodeFieldProfile(int& start, const DataArrayInt *pfl, const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc)
1649 int pos=addNewEntryIfNecessary(INTERP_KERNEL::NORM_ERROR);
1650 _field_pm_pt[pos]->assignNodeFieldProfile(start,pfl,field,arr,glob,nasc);
1653 void MEDFileFieldPerMesh::loadOnlyStructureOfDataRecursively(med_idt fid, int& start, const MEDFileFieldNameScope& nasc)
1655 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1656 (*it)->loadOnlyStructureOfDataRecursively(fid,start,nasc);
1659 void MEDFileFieldPerMesh::loadBigArraysRecursively(med_idt fid, const MEDFileFieldNameScope& nasc)
1661 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1662 (*it)->loadBigArraysRecursively(fid,nasc);
1665 void MEDFileFieldPerMesh::writeLL(med_idt fid, const MEDFileFieldNameScope& nasc) const
1667 int nbOfTypes=_field_pm_pt.size();
1668 for(int i=0;i<nbOfTypes;i++)
1670 _field_pm_pt[i]->copyOptionsFrom(*this);
1671 _field_pm_pt[i]->writeLL(fid,nasc);
1675 void MEDFileFieldPerMesh::getDimension(int& dim) const
1677 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1678 (*it)->getDimension(dim);
1681 void MEDFileFieldPerMesh::fillTypesOfFieldAvailable(std::set<TypeOfField>& types) const
1683 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1684 (*it)->fillTypesOfFieldAvailable(types);
1687 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
1689 int sz=_field_pm_pt.size();
1690 std::vector< std::vector<std::pair<int,int> > > ret(sz);
1691 types.resize(sz); typesF.resize(sz); pfls.resize(sz); locs.resize(sz);
1692 for(int i=0;i<sz;i++)
1694 types[i]=_field_pm_pt[i]->getGeoType();
1695 _field_pm_pt[i]->fillFieldSplitedByType(ret[i],typesF[i],pfls[i],locs[i]);
1700 double MEDFileFieldPerMesh::getTime() const
1703 return _father->getTime(tmp1,tmp2);
1706 int MEDFileFieldPerMesh::getIteration() const
1708 return _father->getIteration();
1711 int MEDFileFieldPerMesh::getOrder() const
1713 return _father->getOrder();
1716 int MEDFileFieldPerMesh::getNumberOfComponents() const
1718 return _father->getNumberOfComponents();
1721 DataArray *MEDFileFieldPerMesh::getOrCreateAndGetArray()
1724 throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getOrCreateAndGetArray : no father ! internal error !");
1725 return _father->getOrCreateAndGetArray();
1728 const DataArray *MEDFileFieldPerMesh::getOrCreateAndGetArray() const
1731 throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getOrCreateAndGetArray : no father ! internal error !");
1732 return _father->getOrCreateAndGetArray();
1735 const std::vector<std::string>& MEDFileFieldPerMesh::getInfo() const
1737 return _father->getInfo();
1741 * type,geoTypes,dads,pfls,locs are input parameters. They should have the same size.
1742 * 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.
1743 * It returns 2 output vectors :
1744 * - 'code' of size 3*sz where sz is the number of different values into 'geoTypes'
1745 * - 'notNullPfls' contains sz2 values that are extracted from 'pfls' in which null profiles have been removed.
1746 * 'code' and 'notNullPfls' are in MEDCouplingUMesh::checkTypeConsistencyAndContig format.
1748 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)
1750 int notNullPflsSz=0;
1751 int nbOfArrs=geoTypes.size();
1752 for(int i=0;i<nbOfArrs;i++)
1755 std::set<INTERP_KERNEL::NormalizedCellType> geoTypes3(geoTypes.begin(),geoTypes.end());
1756 int nbOfDiffGeoTypes=geoTypes3.size();
1757 code.resize(3*nbOfDiffGeoTypes);
1758 notNullPfls.resize(notNullPflsSz);
1761 for(int i=0;i<nbOfDiffGeoTypes;i++)
1764 INTERP_KERNEL::NormalizedCellType refType=geoTypes[j];
1765 std::vector<const DataArrayInt *> notNullTmp;
1767 notNullTmp.push_back(pfls[j]);
1769 for(;j<nbOfArrs;j++)
1770 if(geoTypes[j]==refType)
1773 notNullTmp.push_back(pfls[j]);
1777 std::vector< std::pair<int,int> > tmpDads(dads.begin()+startZone,dads.begin()+j);
1778 std::vector<const DataArrayInt *> tmpPfls(pfls.begin()+startZone,pfls.begin()+j);
1779 std::vector<int> tmpLocs(locs.begin()+startZone,locs.begin()+j);
1780 code[3*i]=(int)refType;
1781 std::vector<INTERP_KERNEL::NormalizedCellType> refType2(1,refType);
1782 code[3*i+1]=ComputeNbOfElems(glob,type,refType2,tmpDads,tmpLocs);
1783 if(notNullTmp.empty())
1787 notNullPfls[notNullPflsSz]=DataArrayInt::Aggregate(notNullTmp);
1788 code[3*i+2]=notNullPflsSz++;
1794 * 'dads' 'geoTypes' and 'locs' are input parameters that should have same size sz. sz should be >=1.
1796 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)
1800 for(int i=0;i<sz;i++)
1804 if(type!=ON_GAUSS_NE)
1805 ret+=dads[i].second-dads[i].first;
1808 const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(geoTypes[i]);
1809 ret+=(dads[i].second-dads[i].first)/cm.getNumberOfNodes();
1814 int nbOfGaussPtPerCell=glob->getNbOfGaussPtPerCell(locs[i]);
1815 ret+=(dads[i].second-dads[i].first)/nbOfGaussPtPerCell;
1821 std::vector<std::string> MEDFileFieldPerMesh::getPflsReallyUsed() const
1823 std::vector<std::string> ret;
1824 std::set<std::string> ret2;
1825 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1827 std::vector<std::string> tmp=(*it)->getPflsReallyUsed();
1828 for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
1829 if(ret2.find(*it2)==ret2.end())
1831 ret.push_back(*it2);
1838 std::vector<std::string> MEDFileFieldPerMesh::getPflsReallyUsedMulti() const
1840 std::vector<std::string> ret;
1841 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1843 std::vector<std::string> tmp=(*it)->getPflsReallyUsedMulti();
1844 ret.insert(ret.end(),tmp.begin(),tmp.end());
1849 std::vector<std::string> MEDFileFieldPerMesh::getLocsReallyUsed() const
1851 std::vector<std::string> ret;
1852 std::set<std::string> ret2;
1853 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1855 std::vector<std::string> tmp=(*it)->getLocsReallyUsed();
1856 for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
1857 if(ret2.find(*it2)==ret2.end())
1859 ret.push_back(*it2);
1866 std::vector<std::string> MEDFileFieldPerMesh::getLocsReallyUsedMulti() const
1868 std::vector<std::string> ret;
1869 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1871 std::vector<std::string> tmp=(*it)->getLocsReallyUsedMulti();
1872 ret.insert(ret.end(),tmp.begin(),tmp.end());
1877 bool MEDFileFieldPerMesh::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab)
1879 for(std::vector< std::pair<std::string,std::string> >::const_iterator it=modifTab.begin();it!=modifTab.end();it++)
1881 if((*it).first==_mesh_name)
1883 _mesh_name=(*it).second;
1890 bool MEDFileFieldPerMesh::renumberEntitiesLyingOnMesh(const std::string& meshName, const std::vector<int>& oldCode, const std::vector<int>& newCode, const DataArrayInt *renumO2N,
1891 MEDFileFieldGlobsReal& glob)
1893 if(_mesh_name!=meshName)
1895 std::set<INTERP_KERNEL::NormalizedCellType> typesToKeep;
1896 for(std::size_t i=0;i<oldCode.size()/3;i++) typesToKeep.insert((INTERP_KERNEL::NormalizedCellType)oldCode[3*i]);
1897 std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > > entries;
1898 std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> entriesKept;
1899 std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> otherEntries;
1900 getUndergroundDataArrayExt(entries);
1901 DataArray *arr0=getOrCreateAndGetArray();//tony
1903 throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::renumberEntitiesLyingOnMesh : DataArray storing values of field is null !");
1904 DataArrayDouble *arr=dynamic_cast<DataArrayDouble *>(arr0);//tony
1906 throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::renumberEntitiesLyingOnMesh : DataArray storing values is double ! Not managed for the moment !");
1909 throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::renumberEntitiesLyingOnMesh : DataArrayDouble storing values of field is null !");
1910 for(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >::const_iterator it=entries.begin();it!=entries.end();it++)
1912 if(typesToKeep.find((*it).first.first)!=typesToKeep.end())
1914 entriesKept.push_back(getLeafGivenTypeAndLocId((*it).first.first,(*it).first.second));
1915 sz+=(*it).second.second-(*it).second.first;
1918 otherEntries.push_back(getLeafGivenTypeAndLocId((*it).first.first,(*it).first.second));
1920 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> renumDefrag=DataArrayInt::New(); renumDefrag->alloc(arr->getNumberOfTuples(),1); renumDefrag->fillWithZero();
1921 ////////////////////
1922 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> explicitIdsOldInMesh=DataArrayInt::New(); explicitIdsOldInMesh->alloc(sz,1);//sz is a majorant of the real size. A realloc will be done after
1923 int *workI2=explicitIdsOldInMesh->getPointer();
1924 int sz1=0,sz2=0,sid=1;
1925 std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> > entriesKeptML=MEDFileFieldPerMeshPerTypePerDisc::SplitPerDiscretization(entriesKept);
1926 // std::vector<int> tupleIdOfStartOfNewChuncksV(entriesKeptML.size());
1927 for(std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> >::const_iterator itL1=entriesKeptML.begin();itL1!=entriesKeptML.end();itL1++,sid++)
1929 // tupleIdOfStartOfNewChuncksV[sid-1]=sz2;
1930 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> explicitIdsOldInArr=DataArrayInt::New(); explicitIdsOldInArr->alloc(sz,1);
1931 int *workI=explicitIdsOldInArr->getPointer();
1932 for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator itL2=(*itL1).begin();itL2!=(*itL1).end();itL2++)
1934 int delta1=(*itL2)->fillTupleIds(workI); workI+=delta1; sz1+=delta1;
1935 (*itL2)->setLocId(sz2);
1936 (*itL2)->_tmp_work1=(*itL2)->getStart();
1937 int delta2=(*itL2)->fillEltIdsFromCode(sz2,oldCode,glob,workI2); workI2+=delta2; sz2+=delta2;
1939 renumDefrag->setPartOfValuesSimple3(sid,explicitIdsOldInArr->begin(),explicitIdsOldInArr->end(),0,1,1);
1941 explicitIdsOldInMesh->reAlloc(sz2);
1942 int tupleIdOfStartOfNewChuncks=arr->getNumberOfTuples()-sz2;
1943 ////////////////////
1944 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> permArrDefrag=renumDefrag->buildPermArrPerLevel(); renumDefrag=0;
1945 // perform redispatching of non concerned MEDFileFieldPerMeshPerTypePerDisc
1946 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> > otherEntriesNew;
1947 for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=otherEntries.begin();it!=otherEntries.end();it++)
1949 otherEntriesNew.push_back(MEDFileFieldPerMeshPerTypePerDisc::New(*(*it)));
1950 otherEntriesNew.back()->setNewStart(permArrDefrag->getIJ((*it)->getStart(),0));
1951 otherEntriesNew.back()->setLocId((*it)->getGeoType());
1953 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> > entriesKeptNew;
1954 std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> entriesKeptNew2;
1955 for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator it=entriesKept.begin();it!=entriesKept.end();it++)
1957 MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerTypePerDisc> elt=MEDFileFieldPerMeshPerTypePerDisc::New(*(*it));
1958 int newStart=elt->getLocId();
1959 elt->setLocId((*it)->getGeoType());
1960 elt->setNewStart(newStart);
1961 elt->_tmp_work1=permArrDefrag->getIJ(elt->_tmp_work1,0);
1962 entriesKeptNew.push_back(elt);
1963 entriesKeptNew2.push_back(elt);
1965 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr2=arr->renumber(permArrDefrag->getConstPointer());
1966 // perform redispatching of concerned MEDFileFieldPerMeshPerTypePerDisc -> values are in arr2
1967 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> explicitIdsNewInMesh=renumO2N->selectByTupleId(explicitIdsOldInMesh->begin(),explicitIdsOldInMesh->end());
1968 std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> > entriesKeptPerDisc=MEDFileFieldPerMeshPerTypePerDisc::SplitPerDiscretization(entriesKeptNew2);
1970 for(std::vector< std::vector< const MEDFileFieldPerMeshPerTypePerDisc *> >::const_iterator it4=entriesKeptPerDisc.begin();it4!=entriesKeptPerDisc.end();it4++)
1973 /*for(std::vector< const MEDFileFieldPerMeshPerTypePerDisc *>::const_iterator itL2=(*it4).begin();itL2!=(*it4).end();itL2++)
1975 MEDFileFieldPerMeshPerTypePerDisc *curNC=const_cast<MEDFileFieldPerMeshPerTypePerDisc *>(*itL2);
1976 curNC->setNewStart(permArrDefrag->getIJ((*itL2)->getStart(),0)-tupleIdOfStartOfNewChuncks+tupleIdOfStartOfNewChuncksV[sid]);
1978 ret=MEDFileFieldPerMeshPerTypePerDisc::RenumberChunks(tupleIdOfStartOfNewChuncks,*it4,explicitIdsNewInMesh,newCode,
1979 glob,arr2,otherEntriesNew) || ret;
1983 // Assign new dispatching
1984 assignNewLeaves(otherEntriesNew);
1985 arr->cpyFrom(*arr2);
1990 * \param [in,out] globalNum a global numbering counter for the renumbering.
1991 * \param [out] its - list of pair (start,stop) kept
1993 void MEDFileFieldPerMesh::keepOnlySpatialDiscretization(TypeOfField tof, int &globalNum, std::vector< std::pair<int,int> >& its)
1995 std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > > ret;
1996 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
1998 std::vector< std::pair<int,int> > its2;
1999 if((*it)->keepOnlySpatialDiscretization(tof,globalNum,its2))
2002 its.insert(its.end(),its2.begin(),its2.end());
2008 void MEDFileFieldPerMesh::assignNewLeaves(const std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerTypePerDisc > >& leaves)
2010 std::map<INTERP_KERNEL::NormalizedCellType,std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerTypePerDisc> > > types;
2011 for( std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerTypePerDisc > >::const_iterator it=leaves.begin();it!=leaves.end();it++)
2012 types[(INTERP_KERNEL::NormalizedCellType)(*it)->getLocId()].push_back(*it);
2014 std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > > fieldPmPt(types.size());
2015 std::map<INTERP_KERNEL::NormalizedCellType,std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerTypePerDisc> > >::const_iterator it1=types.begin();
2016 std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it2=fieldPmPt.begin();
2017 for(;it1!=types.end();it1++,it2++)
2019 MEDCouplingAutoRefCountObjectPtr<MEDFileFieldPerMeshPerType> elt=MEDFileFieldPerMeshPerType::New(this,(INTERP_KERNEL::NormalizedCellType)((*it1).second[0]->getLocId()));
2020 elt->setLeaves((*it1).second);
2023 _field_pm_pt=fieldPmPt;
2026 void MEDFileFieldPerMesh::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
2028 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2029 (*it)->changePflsRefsNamesGen(mapOfModif);
2032 void MEDFileFieldPerMesh::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
2034 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2035 (*it)->changeLocsRefsNamesGen(mapOfModif);
2039 * \param [in] mesh is the whole mesh
2041 MEDCouplingFieldDouble *MEDFileFieldPerMesh::getFieldOnMeshAtLevel(TypeOfField type, const MEDFileFieldGlobsReal *glob, const MEDCouplingMesh *mesh, bool& isPfl, MEDCouplingAutoRefCountObjectPtr<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const
2043 if(_field_pm_pt.empty())
2044 throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getFieldOnMeshAtLevel : no types field set !");
2046 std::vector< std::pair<int,int> > dads;
2047 std::vector<const DataArrayInt *> pfls;
2048 std::vector<DataArrayInt *> notNullPflsPerGeoType;
2049 std::vector<int> locs,code;
2050 std::vector<INTERP_KERNEL::NormalizedCellType> geoTypes;
2051 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2052 (*it)->getFieldAtLevel(mesh->getMeshDimension(),type,glob,dads,pfls,locs,geoTypes);
2054 SortArraysPerType(glob,type,geoTypes,dads,pfls,locs,code,notNullPflsPerGeoType);
2057 std::ostringstream oss; oss << "MEDFileFieldPerMesh::getFieldOnMeshAtLevel : " << "The field \"" << nasc.getName() << "\" exists but not with such spatial discretization or such dimension specified !";
2058 throw INTERP_KERNEL::Exception(oss.str().c_str());
2061 std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > notNullPflsPerGeoType2(notNullPflsPerGeoType.begin(),notNullPflsPerGeoType.end());
2062 std::vector< const DataArrayInt *> notNullPflsPerGeoType3(notNullPflsPerGeoType.begin(),notNullPflsPerGeoType.end());
2065 DataArrayInt *arr=mesh->checkTypeConsistencyAndContig(code,notNullPflsPerGeoType3);
2067 return finishField(type,glob,dads,locs,mesh,isPfl,arrOut,nasc);
2070 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr2(arr);
2071 return finishField2(type,glob,dads,locs,geoTypes,mesh,arr,isPfl,arrOut,nasc);
2077 throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getFieldOnMeshAtLevel : internal error #1 !");
2081 if(nb!=mesh->getNumberOfNodes())
2083 std::ostringstream oss; oss << "MEDFileFieldPerMesh::getFieldOnMeshAtLevel : There is a problem there is " << nb << " nodes in field whereas there is " << mesh->getNumberOfNodes();
2084 oss << " nodes in mesh !";
2085 throw INTERP_KERNEL::Exception(oss.str().c_str());
2087 return finishField(type,glob,dads,locs,mesh,isPfl,arrOut,nasc);
2090 return finishFieldNode2(glob,dads,locs,mesh,notNullPflsPerGeoType3[0],isPfl,arrOut,nasc);
2094 DataArray *MEDFileFieldPerMesh::getFieldOnMeshAtLevelWithPfl(TypeOfField type, const MEDCouplingMesh *mesh, DataArrayInt *&pfl, const MEDFileFieldGlobsReal *glob, const MEDFileFieldNameScope& nasc) const
2096 if(_field_pm_pt.empty())
2097 throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getFieldOnMeshAtLevel : no types field set !");
2099 std::vector<std::pair<int,int> > dads;
2100 std::vector<const DataArrayInt *> pfls;
2101 std::vector<DataArrayInt *> notNullPflsPerGeoType;
2102 std::vector<int> locs,code;
2103 std::vector<INTERP_KERNEL::NormalizedCellType> geoTypes;
2104 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2105 (*it)->getFieldAtLevel(mesh->getMeshDimension(),type,glob,dads,pfls,locs,geoTypes);
2107 SortArraysPerType(glob,type,geoTypes,dads,pfls,locs,code,notNullPflsPerGeoType);
2110 std::ostringstream oss; oss << "MEDFileFieldPerMesh::getFieldOnMeshAtLevelWithPfl : " << "The field \"" << nasc.getName() << "\" exists but not with such spatial discretization or such dimension specified !";
2111 throw INTERP_KERNEL::Exception(oss.str().c_str());
2113 std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > notNullPflsPerGeoType2(notNullPflsPerGeoType.begin(),notNullPflsPerGeoType.end());
2114 std::vector< const DataArrayInt *> notNullPflsPerGeoType3(notNullPflsPerGeoType.begin(),notNullPflsPerGeoType.end());
2117 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr=mesh->checkTypeConsistencyAndContig(code,notNullPflsPerGeoType3);
2118 return finishField4(dads,arr,mesh->getNumberOfCells(),pfl);
2123 throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::getFieldOnMeshAtLevel : internal error #1 !");
2127 if(nb!=mesh->getNumberOfNodes())
2129 std::ostringstream oss; oss << "MEDFileFieldPerMesh::getFieldOnMeshAtLevel : There is a problem there is " << nb << " nodes in field whereas there is " << mesh->getNumberOfNodes();
2130 oss << " nodes in mesh !";
2131 throw INTERP_KERNEL::Exception(oss.str().c_str());
2134 return finishField4(dads,code[2]==-1?0:notNullPflsPerGeoType3[0],mesh->getNumberOfNodes(),pfl);
2140 void MEDFileFieldPerMesh::getUndergroundDataArrayExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
2144 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2146 (*it)->getSizes(globalSz,nbOfEntries);
2148 entries.resize(nbOfEntries);
2150 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2152 (*it)->fillValues(nbOfEntries,entries);
2156 MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMesh::getLeafGivenTypeAndLocId(INTERP_KERNEL::NormalizedCellType typ, int locId)
2158 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2160 if((*it)->getGeoType()==typ)
2161 return (*it)->getLeafGivenLocId(locId);
2163 const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(typ);
2164 std::ostringstream oss; oss << "MEDFileFieldPerMesh::getLeafGivenTypeAndLocId : no such geometric type \"" << cm.getRepr() << "\" in this !" << std::endl;
2165 oss << "Possiblities are : ";
2166 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2168 const INTERP_KERNEL::CellModel& cm2=INTERP_KERNEL::CellModel::GetCellModel((*it)->getGeoType());
2169 oss << "\"" << cm2.getRepr() << "\", ";
2171 throw INTERP_KERNEL::Exception(oss.str().c_str());
2174 const MEDFileFieldPerMeshPerTypePerDisc *MEDFileFieldPerMesh::getLeafGivenTypeAndLocId(INTERP_KERNEL::NormalizedCellType typ, int locId) const
2176 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2178 if((*it)->getGeoType()==typ)
2179 return (*it)->getLeafGivenLocId(locId);
2181 const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(typ);
2182 std::ostringstream oss; oss << "MEDFileFieldPerMesh::getLeafGivenTypeAndLocId : no such geometric type \"" << cm.getRepr() << "\" in this !" << std::endl;
2183 oss << "Possiblities are : ";
2184 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::const_iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++)
2186 const INTERP_KERNEL::CellModel& cm2=INTERP_KERNEL::CellModel::GetCellModel((*it)->getGeoType());
2187 oss << "\"" << cm2.getRepr() << "\", ";
2189 throw INTERP_KERNEL::Exception(oss.str().c_str());
2192 int MEDFileFieldPerMesh::addNewEntryIfNecessary(INTERP_KERNEL::NormalizedCellType type)
2195 int pos=std::distance(typmai2,std::find(typmai2,typmai2+MED_N_CELL_FIXED_GEO,type));
2196 std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it2=_field_pm_pt.begin();
2197 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMeshPerType > >::iterator it=_field_pm_pt.begin();it!=_field_pm_pt.end();it++,i++)
2199 INTERP_KERNEL::NormalizedCellType curType=(*it)->getGeoType();
2204 int pos2=std::distance(typmai2,std::find(typmai2,typmai2+MED_N_CELL_FIXED_GEO,curType));
2209 int ret=std::distance(_field_pm_pt.begin(),it2);
2210 _field_pm_pt.insert(it2,MEDFileFieldPerMeshPerType::New(this,type));
2215 * 'dads' and 'locs' input parameters have the same number of elements
2216 * \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
2218 MEDCouplingFieldDouble *MEDFileFieldPerMesh::finishField(TypeOfField type, const MEDFileFieldGlobsReal *glob,
2219 const std::vector< std::pair<int,int> >& dads, const std::vector<int>& locs,
2220 const MEDCouplingMesh *mesh, bool& isPfl, MEDCouplingAutoRefCountObjectPtr<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const throw(INTERP_KERNEL::Exception)
2223 MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=MEDCouplingFieldDouble::New(type,ONE_TIME);
2224 ret->setMesh(mesh); ret->setName(nasc.getName().c_str()); ret->setTime(getTime(),getIteration(),getOrder()); ret->setTimeUnit(nasc.getDtUnit().c_str());
2225 MEDCouplingAutoRefCountObjectPtr<DataArray> da=getOrCreateAndGetArray()->selectByTupleRanges(dads);
2226 const std::vector<std::string>& infos=getInfo();
2227 da->setInfoOnComponents(infos);
2229 if(type==ON_GAUSS_PT)
2232 int nbOfArrs=dads.size();
2233 for(int i=0;i<nbOfArrs;i++)
2235 std::vector<std::pair<int,int> > dads2(1,dads[i]); const std::vector<int> locs2(1,locs[i]);
2236 const std::vector<INTERP_KERNEL::NormalizedCellType> geoTypes2(1,INTERP_KERNEL::NORM_ERROR);
2237 int nbOfElems=ComputeNbOfElems(glob,type,geoTypes2,dads2,locs2);
2238 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> di=DataArrayInt::New();
2239 di->alloc(nbOfElems,1);
2241 const MEDFileFieldLoc& fl=glob->getLocalizationFromId(locs[i]);
2242 ret->setGaussLocalizationOnCells(di->getConstPointer(),di->getConstPointer()+nbOfElems,fl.getRefCoords(),fl.getGaussCoords(),fl.getGaussWeights());
2251 * 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.
2252 * 'dads', 'locs' and 'geoTypes' input parameters have the same number of elements.
2253 * No check of this is performed. 'da' array contains an array in old2New style to be applyied to mesh to obtain the right support.
2254 * The order of cells in the returned field is those imposed by the profile.
2255 * \param [in] mesh is the global mesh.
2257 MEDCouplingFieldDouble *MEDFileFieldPerMesh::finishField2(TypeOfField type, const MEDFileFieldGlobsReal *glob,
2258 const std::vector<std::pair<int,int> >& dads, const std::vector<int>& locs,
2259 const std::vector<INTERP_KERNEL::NormalizedCellType>& geoTypes,
2260 const MEDCouplingMesh *mesh, const DataArrayInt *da, bool& isPfl, MEDCouplingAutoRefCountObjectPtr<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const throw(INTERP_KERNEL::Exception)
2262 if(da->isIdentity())
2264 int nbOfTuples=da->getNumberOfTuples();
2265 if(nbOfTuples==mesh->getNumberOfCells())
2266 return finishField(type,glob,dads,locs,mesh,isPfl,arrOut,nasc);
2268 MEDCouplingAutoRefCountObjectPtr<MEDCouplingMesh> m2=mesh->buildPart(da->getConstPointer(),da->getConstPointer()+da->getNbOfElems());
2269 m2->setName(mesh->getName().c_str());
2270 MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=finishField(type,glob,dads,locs,m2,isPfl,arrOut,nasc);
2276 * This method is the complement of MEDFileFieldPerMesh::finishField2 method except that this method works for node profiles.
2278 MEDCouplingFieldDouble *MEDFileFieldPerMesh::finishFieldNode2(const MEDFileFieldGlobsReal *glob,
2279 const std::vector<std::pair<int,int> >& dads, const std::vector<int>& locs,
2280 const MEDCouplingMesh *mesh, const DataArrayInt *da, bool& isPfl, MEDCouplingAutoRefCountObjectPtr<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const throw(INTERP_KERNEL::Exception)
2282 if(da->isIdentity())
2284 int nbOfTuples=da->getNumberOfTuples();
2285 if(nbOfTuples==mesh->getNumberOfNodes())//No problem for NORM_ERROR because it is in context of node
2286 return finishField(ON_NODES,glob,dads,locs,mesh,isPfl,arrOut,nasc);
2288 // Treatment of particular case where nodal field on pfl is requested with a meshDimRelToMax=1.
2289 const MEDCouplingUMesh *meshu=dynamic_cast<const MEDCouplingUMesh *>(mesh);
2292 if(meshu->getNodalConnectivity()==0)
2294 MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=finishField(ON_CELLS,glob,dads,locs,mesh,isPfl,arrOut,nasc);
2295 int nb=da->getNbOfElems();
2296 const int *ptr=da->getConstPointer();
2297 MEDCouplingUMesh *meshuc=const_cast<MEDCouplingUMesh *>(meshu);
2298 meshuc->allocateCells(nb);
2299 for(int i=0;i<nb;i++)
2300 meshuc->insertNextCell(INTERP_KERNEL::NORM_POINT1,1,ptr+i);
2301 meshuc->finishInsertingCells();
2302 ret->setMesh(meshuc);
2303 const MEDCouplingFieldDiscretization *disc=ret->getDiscretization();
2304 if(!disc) throw INTERP_KERNEL::Exception("MEDFileFieldPerMesh::finishFieldNode2 : internal error, no discretization on field !");
2305 disc->checkCoherencyBetween(meshuc,arrOut);
2310 MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=finishField(ON_NODES,glob,dads,locs,mesh,isPfl,arrOut,nasc);
2312 DataArrayInt *arr2=0;
2313 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> cellIds=mesh->getCellIdsFullyIncludedInNodeIds(da->getConstPointer(),da->getConstPointer()+da->getNbOfElems());
2314 MEDCouplingAutoRefCountObjectPtr<MEDCouplingMesh> mesh2=mesh->buildPartAndReduceNodes(cellIds->getConstPointer(),cellIds->getConstPointer()+cellIds->getNbOfElems(),arr2);
2315 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr3(arr2);
2316 int nnodes=mesh2->getNumberOfNodes();
2317 if(nnodes==(int)da->getNbOfElems())
2319 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da3=da->transformWithIndArrR(arr2->begin(),arr2->end());
2320 arrOut->renumberInPlace(da3->getConstPointer());
2321 mesh2->setName(mesh->getName().c_str());
2322 ret->setMesh(mesh2);
2327 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 !!!";
2328 oss << "So it is impossible to return a well definied MEDCouplingFieldDouble instance on specified mesh on a specified meshDim !" << std::endl;
2329 oss << "To retrieve correctly such a field you have 3 possibilities :" << std::endl;
2330 oss << " - use an another meshDim compatible with the field on nodes (MED file does not have such information)" << std::endl;
2331 oss << " - use an another a meshDimRelToMax equal to 1 -> it will return a mesh with artificial cell POINT1 containing the profile !" << std::endl;
2332 oss << " - if definitely the node profile has no link with mesh connectivity use MEDFileField1TS::getFieldWithProfile or MEDFileFieldMultiTS::getFieldWithProfile methods instead !";
2333 throw INTERP_KERNEL::Exception(oss.str().c_str());
2339 * This method is the most light method of field retrieving.
2341 DataArray *MEDFileFieldPerMesh::finishField4(const std::vector<std::pair<int,int> >& dads, const DataArrayInt *pflIn, int nbOfElems, DataArrayInt *&pflOut) const
2345 pflOut=DataArrayInt::New();
2346 pflOut->alloc(nbOfElems,1);
2351 pflOut=const_cast<DataArrayInt*>(pflIn);
2354 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> safePfl(pflOut);
2355 MEDCouplingAutoRefCountObjectPtr<DataArray> da=getOrCreateAndGetArray()->selectByTupleRanges(dads);
2356 const std::vector<std::string>& infos=getInfo();
2357 int nbOfComp=infos.size();
2358 for(int i=0;i<nbOfComp;i++)
2359 da->setInfoOnComponent(i,infos[i].c_str());
2364 MEDFileFieldPerMesh::MEDFileFieldPerMesh(med_idt fid, MEDFileAnyTypeField1TSWithoutSDA *fath, int meshCsit, int meshIteration, int meshOrder, const MEDFileFieldNameScope& nasc):_mesh_iteration(meshIteration),_mesh_order(meshOrder),
2365 _mesh_csit(meshCsit),_father(fath)
2367 INTERP_KERNEL::AutoPtr<char> meshName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
2368 INTERP_KERNEL::AutoPtr<char> pflName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
2369 INTERP_KERNEL::AutoPtr<char> locName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
2370 for(int i=0;i<MED_N_CELL_FIXED_GEO;i++)
2372 int nbProfile =MEDfield23nProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_CELL ,typmai[i],_mesh_csit,meshName,pflName,locName);
2373 std::string name0(MEDLoaderBase::buildStringFromFortran(meshName,MED_NAME_SIZE+1));
2374 int nbProfile2=MEDfield23nProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_NODE_ELEMENT,typmai[i],_mesh_csit,meshName,pflName,locName);
2375 std::string name1(MEDLoaderBase::buildStringFromFortran(meshName,MED_NAME_SIZE+1));
2376 if(nbProfile>0 || nbProfile2>0)
2378 _field_pm_pt.push_back(MEDFileFieldPerMeshPerType::NewOnRead(fid,this,ON_CELLS,typmai2[i],nasc));
2385 int nbProfile=MEDfield23nProfile(fid,nasc.getName().c_str(),getIteration(),getOrder(),MED_NODE,MED_NONE,_mesh_csit,meshName,pflName,locName);
2388 _field_pm_pt.push_back(MEDFileFieldPerMeshPerType::NewOnRead(fid,this,ON_NODES,INTERP_KERNEL::NORM_ERROR,nasc));
2389 _mesh_name=MEDLoaderBase::buildStringFromFortran(meshName,MED_NAME_SIZE+1);
2393 MEDFileFieldPerMesh::MEDFileFieldPerMesh(MEDFileAnyTypeField1TSWithoutSDA *fath, const MEDCouplingMesh *mesh):_father(fath)
2395 copyTinyInfoFrom(mesh);
2398 void MEDFileFieldGlobs::loadProfileInFile(med_idt fid, int id, const std::string& pflName)
2400 if(id>=(int)_pfls.size())
2402 _pfls[id]=DataArrayInt::New();
2403 int lgth=MEDprofileSizeByName(fid,pflName.c_str());
2404 _pfls[id]->setName(pflName);
2405 _pfls[id]->alloc(lgth,1);
2406 MEDprofileRd(fid,pflName.c_str(),_pfls[id]->getPointer());
2407 _pfls[id]->applyLin(1,-1,0);//Converting into C format
2410 void MEDFileFieldGlobs::loadProfileInFile(med_idt fid, int i)
2412 INTERP_KERNEL::AutoPtr<char> pflName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
2414 MEDprofileInfo(fid,i+1,pflName,&sz);
2415 std::string pflCpp=MEDLoaderBase::buildStringFromFortran(pflName,MED_NAME_SIZE);
2416 if(i>=(int)_pfls.size())
2418 _pfls[i]=DataArrayInt::New();
2419 _pfls[i]->alloc(sz,1);
2420 _pfls[i]->setName(pflCpp.c_str());
2421 MEDprofileRd(fid,pflName,_pfls[i]->getPointer());
2422 _pfls[i]->applyLin(1,-1,0);//Converting into C format
2425 void MEDFileFieldGlobs::writeGlobals(med_idt fid, const MEDFileWritable& opt) const
2427 int nbOfPfls=_pfls.size();
2428 for(int i=0;i<nbOfPfls;i++)
2430 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> cpy=_pfls[i]->deepCpy();
2431 cpy->applyLin(1,1,0);
2432 INTERP_KERNEL::AutoPtr<char> pflName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
2433 MEDLoaderBase::safeStrCpy(_pfls[i]->getName().c_str(),MED_NAME_SIZE,pflName,opt.getTooLongStrPolicy());
2434 MEDprofileWr(fid,pflName,_pfls[i]->getNumberOfTuples(),cpy->getConstPointer());
2437 int nbOfLocs=_locs.size();
2438 for(int i=0;i<nbOfLocs;i++)
2439 _locs[i]->writeLL(fid);
2442 void MEDFileFieldGlobs::appendGlobs(const MEDFileFieldGlobs& other, double eps)
2444 std::vector<std::string> pfls=getPfls();
2445 for(std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::const_iterator it=other._pfls.begin();it!=other._pfls.end();it++)
2447 std::vector<std::string>::iterator it2=std::find(pfls.begin(),pfls.end(),(*it)->getName());
2450 _pfls.push_back(*it);
2454 int id=std::distance(pfls.begin(),it2);
2455 if(!(*it)->isEqual(*_pfls[id]))
2457 std::ostringstream oss; oss << "MEDFileFieldGlobs::appendGlobs : Profile \"" << (*it)->getName() << "\" already exists and is different from those expecting to be append !";
2458 throw INTERP_KERNEL::Exception(oss.str().c_str());
2462 std::vector<std::string> locs=getLocs();
2463 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> >::const_iterator it=other._locs.begin();it!=other._locs.end();it++)
2465 std::vector<std::string>::iterator it2=std::find(locs.begin(),locs.end(),(*it)->getName());
2468 _locs.push_back(*it);
2472 int id=std::distance(locs.begin(),it2);
2473 if(!(*it)->isEqual(*_locs[id],eps))
2475 std::ostringstream oss; oss << "MEDFileFieldGlobs::appendGlobs : Localization \"" << (*it)->getName() << "\" already exists and is different from those expecting to be append !";
2476 throw INTERP_KERNEL::Exception(oss.str().c_str());
2482 void MEDFileFieldGlobs::checkGlobsPflsPartCoherency(const std::vector<std::string>& pflsUsed) const
2484 for(std::vector<std::string>::const_iterator it=pflsUsed.begin();it!=pflsUsed.end();it++)
2485 getProfile((*it).c_str());
2488 void MEDFileFieldGlobs::checkGlobsLocsPartCoherency(const std::vector<std::string>& locsUsed) const
2490 for(std::vector<std::string>::const_iterator it=locsUsed.begin();it!=locsUsed.end();it++)
2491 getLocalization((*it).c_str());
2494 void MEDFileFieldGlobs::loadGlobals(med_idt fid, const MEDFileFieldGlobsReal& real)
2496 std::vector<std::string> profiles=real.getPflsReallyUsed();
2497 int sz=profiles.size();
2499 for(int i=0;i<sz;i++)
2500 loadProfileInFile(fid,i,profiles[i].c_str());
2502 std::vector<std::string> locs=real.getLocsReallyUsed();
2505 for(int i=0;i<sz;i++)
2506 _locs[i]=MEDFileFieldLoc::New(fid,locs[i].c_str());
2509 void MEDFileFieldGlobs::loadAllGlobals(med_idt fid)
2511 int nProfil=MEDnProfile(fid);
2512 for(int i=0;i<nProfil;i++)
2513 loadProfileInFile(fid,i);
2514 int sz=MEDnLocalization(fid);
2516 for(int i=0;i<sz;i++)
2518 _locs[i]=MEDFileFieldLoc::New(fid,i);
2522 MEDFileFieldGlobs *MEDFileFieldGlobs::New(const std::string& fname)
2524 return new MEDFileFieldGlobs(fname);
2527 MEDFileFieldGlobs *MEDFileFieldGlobs::New()
2529 return new MEDFileFieldGlobs;
2532 std::size_t MEDFileFieldGlobs::getHeapMemorySizeWithoutChildren() const
2534 return _file_name.capacity()+_pfls.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr<DataArrayInt>)+_locs.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc>);
2537 std::vector<const BigMemoryObject *> MEDFileFieldGlobs::getDirectChildren() const
2539 std::vector<const BigMemoryObject *> ret;
2540 for(std::vector< MEDCouplingAutoRefCountObjectPtr< DataArrayInt > >::const_iterator it=_pfls.begin();it!=_pfls.end();it++)
2542 const DataArrayInt *cur(*it);
2546 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> >::const_iterator it=_locs.begin();it!=_locs.end();it++)
2548 const MEDFileFieldLoc *cur(*it);
2555 MEDFileFieldGlobs *MEDFileFieldGlobs::deepCpy() const
2557 MEDCouplingAutoRefCountObjectPtr<MEDFileFieldGlobs> ret=new MEDFileFieldGlobs(*this);
2559 for(std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::const_iterator it=_pfls.begin();it!=_pfls.end();it++,i++)
2561 if((const DataArrayInt *)*it)
2562 ret->_pfls[i]=(*it)->deepCpy();
2565 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> >::const_iterator it=_locs.begin();it!=_locs.end();it++,i++)
2567 if((const MEDFileFieldLoc*)*it)
2568 ret->_locs[i]=(*it)->deepCpy();
2574 * \throw if a profile in \a pfls in not in \a this.
2575 * \throw if a localization in \a locs in not in \a this.
2576 * \sa MEDFileFieldGlobs::deepCpyPart
2578 MEDFileFieldGlobs *MEDFileFieldGlobs::shallowCpyPart(const std::vector<std::string>& pfls, const std::vector<std::string>& locs) const
2580 MEDCouplingAutoRefCountObjectPtr<MEDFileFieldGlobs> ret=MEDFileFieldGlobs::New();
2581 for(std::vector<std::string>::const_iterator it1=pfls.begin();it1!=pfls.end();it1++)
2583 DataArrayInt *pfl=const_cast<DataArrayInt *>(getProfile((*it1).c_str()));
2585 throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::shallowCpyPart : internal error ! pfl null !");
2587 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> pfl2(pfl);
2588 ret->_pfls.push_back(pfl2);
2590 for(std::vector<std::string>::const_iterator it2=locs.begin();it2!=locs.end();it2++)
2592 MEDFileFieldLoc *loc=const_cast<MEDFileFieldLoc *>(&getLocalization((*it2).c_str()));
2594 throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::shallowCpyPart : internal error ! loc null !");
2596 MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> loc2(loc);
2597 ret->_locs.push_back(loc2);
2599 ret->setFileName(getFileName());
2604 * \throw if a profile in \a pfls in not in \a this.
2605 * \throw if a localization in \a locs in not in \a this.
2606 * \sa MEDFileFieldGlobs::shallowCpyPart
2608 MEDFileFieldGlobs *MEDFileFieldGlobs::deepCpyPart(const std::vector<std::string>& pfls, const std::vector<std::string>& locs) const
2610 MEDCouplingAutoRefCountObjectPtr<MEDFileFieldGlobs> ret=MEDFileFieldGlobs::New();
2611 for(std::vector<std::string>::const_iterator it1=pfls.begin();it1!=pfls.end();it1++)
2613 DataArrayInt *pfl=const_cast<DataArrayInt *>(getProfile((*it1).c_str()));
2615 throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::deepCpyPart : internal error ! pfl null !");
2616 ret->_pfls.push_back(pfl->deepCpy());
2618 for(std::vector<std::string>::const_iterator it2=locs.begin();it2!=locs.end();it2++)
2620 MEDFileFieldLoc *loc=const_cast<MEDFileFieldLoc *>(&getLocalization((*it2).c_str()));
2622 throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::deepCpyPart : internal error ! loc null !");
2623 ret->_locs.push_back(loc->deepCpy());
2625 ret->setFileName(getFileName());
2629 MEDFileFieldGlobs::MEDFileFieldGlobs(const std::string& fname):_file_name(fname)
2633 MEDFileFieldGlobs::MEDFileFieldGlobs()
2637 MEDFileFieldGlobs::~MEDFileFieldGlobs()
2641 void MEDFileFieldGlobs::simpleRepr(std::ostream& oss) const
2643 oss << "Profiles :\n";
2644 std::size_t n=_pfls.size();
2645 for(std::size_t i=0;i<n;i++)
2647 oss << " - #" << i << " ";
2648 const DataArrayInt *pfl=_pfls[i];
2650 oss << "\"" << pfl->getName() << "\"\n";
2655 oss << "Localizations :\n";
2656 for(std::size_t i=0;i<n;i++)
2658 oss << " - #" << i << " ";
2659 const MEDFileFieldLoc *loc=_locs[i];
2661 loc->simpleRepr(oss);
2667 void MEDFileFieldGlobs::setFileName(const std::string& fileName)
2669 _file_name=fileName;
2672 void MEDFileFieldGlobs::changePflsNamesInStruct(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
2674 for(std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::iterator it=_pfls.begin();it!=_pfls.end();it++)
2676 DataArrayInt *elt(*it);
2679 std::string name(elt->getName());
2680 for(std::vector< std::pair<std::vector<std::string>, std::string > >::const_iterator it2=mapOfModif.begin();it2!=mapOfModif.end();it2++)
2682 if(std::find((*it2).first.begin(),(*it2).first.end(),name)!=(*it2).first.end())
2684 elt->setName((*it2).second.c_str());
2692 void MEDFileFieldGlobs::changeLocsNamesInStruct(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
2694 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> >::iterator it=_locs.begin();it!=_locs.end();it++)
2696 MEDFileFieldLoc *elt(*it);
2699 std::string name(elt->getName());
2700 for(std::vector< std::pair<std::vector<std::string>, std::string > >::const_iterator it2=mapOfModif.begin();it2!=mapOfModif.end();it2++)
2702 if(std::find((*it2).first.begin(),(*it2).first.end(),name)!=(*it2).first.end())
2704 elt->setName((*it2).second.c_str());
2712 int MEDFileFieldGlobs::getNbOfGaussPtPerCell(int locId) const
2714 if(locId<0 || locId>=(int)_locs.size())
2715 throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::getNbOfGaussPtPerCell : Invalid localization id !");
2716 return _locs[locId]->getNbOfGaussPtPerCell();
2719 const MEDFileFieldLoc& MEDFileFieldGlobs::getLocalization(const std::string& locName) const
2721 return getLocalizationFromId(getLocalizationId(locName));
2724 const MEDFileFieldLoc& MEDFileFieldGlobs::getLocalizationFromId(int locId) const
2726 if(locId<0 || locId>=(int)_locs.size())
2727 throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::getLocalizationFromId : Invalid localization id !");
2728 return *_locs[locId];
2731 namespace ParaMEDMEMImpl
2736 LocFinder(const std::string& loc):_loc(loc) { }
2737 bool operator() (const MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc>& loc) { return loc->isName(_loc); }
2739 const std::string &_loc;
2745 PflFinder(const std::string& pfl):_pfl(pfl) { }
2746 bool operator() (const MEDCouplingAutoRefCountObjectPtr<DataArrayInt>& pfl) { return _pfl==pfl->getName(); }
2748 const std::string& _pfl;
2752 int MEDFileFieldGlobs::getLocalizationId(const std::string& loc) const
2754 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> >::const_iterator it=std::find_if(_locs.begin(),_locs.end(),ParaMEDMEMImpl::LocFinder(loc));
2757 std::ostringstream oss; oss << "MEDFileFieldGlobs::getLocalisationId : no such localisation name : \"" << loc << "\" Possible localizations are : ";
2758 for(it=_locs.begin();it!=_locs.end();it++)
2759 oss << "\"" << (*it)->getName() << "\", ";
2760 throw INTERP_KERNEL::Exception(oss.str().c_str());
2762 return std::distance(_locs.begin(),it);
2766 * The returned value is never null.
2768 const DataArrayInt *MEDFileFieldGlobs::getProfile(const std::string& pflName) const
2770 std::string pflNameCpp(pflName);
2771 std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::const_iterator it=std::find_if(_pfls.begin(),_pfls.end(),ParaMEDMEMImpl::PflFinder(pflNameCpp));
2774 std::ostringstream oss; oss << "MEDFileFieldGlobs::getProfile: no such profile name : \"" << pflNameCpp << "\" Possible profiles are : ";
2775 for(it=_pfls.begin();it!=_pfls.end();it++)
2776 oss << "\"" << (*it)->getName() << "\", ";
2777 throw INTERP_KERNEL::Exception(oss.str().c_str());
2782 const DataArrayInt *MEDFileFieldGlobs::getProfileFromId(int pflId) const
2784 if(pflId<0 || pflId>=(int)_pfls.size())
2785 throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::getProfileFromId : Invalid profile id !");
2786 return _pfls[pflId];
2789 MEDFileFieldLoc& MEDFileFieldGlobs::getLocalizationFromId(int locId)
2791 if(locId<0 || locId>=(int)_locs.size())
2792 throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::getLocalizationFromId : Invalid localization id !");
2793 return *_locs[locId];
2796 MEDFileFieldLoc& MEDFileFieldGlobs::getLocalization(const std::string& locName)
2798 return getLocalizationFromId(getLocalizationId(locName));
2802 * The returned value is never null.
2804 DataArrayInt *MEDFileFieldGlobs::getProfile(const std::string& pflName)
2806 std::string pflNameCpp(pflName);
2807 std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::iterator it=std::find_if(_pfls.begin(),_pfls.end(),ParaMEDMEMImpl::PflFinder(pflNameCpp));
2810 std::ostringstream oss; oss << "MEDFileFieldGlobs::getProfile: no such profile name : \"" << pflNameCpp << "\" Possible profiles are : ";
2811 for(it=_pfls.begin();it!=_pfls.end();it++)
2812 oss << "\"" << (*it)->getName() << "\", ";
2813 throw INTERP_KERNEL::Exception(oss.str().c_str());
2818 DataArrayInt *MEDFileFieldGlobs::getProfileFromId(int pflId)
2820 if(pflId<0 || pflId>=(int)_pfls.size())
2821 throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::getProfileFromId : Invalid profile id !");
2822 return _pfls[pflId];
2825 void MEDFileFieldGlobs::killProfileIds(const std::vector<int>& pflIds)
2827 std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > newPfls;
2829 for(std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::const_iterator it=_pfls.begin();it!=_pfls.end();it++,i++)
2831 if(std::find(pflIds.begin(),pflIds.end(),i)==pflIds.end())
2832 newPfls.push_back(*it);
2837 void MEDFileFieldGlobs::killLocalizationIds(const std::vector<int>& locIds)
2839 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> > newLocs;
2841 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> >::const_iterator it=_locs.begin();it!=_locs.end();it++,i++)
2843 if(std::find(locIds.begin(),locIds.end(),i)==locIds.end())
2844 newLocs.push_back(*it);
2849 std::vector<std::string> MEDFileFieldGlobs::getPfls() const
2851 int sz=_pfls.size();
2852 std::vector<std::string> ret(sz);
2853 for(int i=0;i<sz;i++)
2854 ret[i]=_pfls[i]->getName();
2858 std::vector<std::string> MEDFileFieldGlobs::getLocs() const
2860 int sz=_locs.size();
2861 std::vector<std::string> ret(sz);
2862 for(int i=0;i<sz;i++)
2863 ret[i]=_locs[i]->getName();
2867 bool MEDFileFieldGlobs::existsPfl(const std::string& pflName) const
2869 std::vector<std::string> v=getPfls();
2870 std::string s(pflName);
2871 return std::find(v.begin(),v.end(),s)!=v.end();
2874 bool MEDFileFieldGlobs::existsLoc(const std::string& locName) const
2876 std::vector<std::string> v=getLocs();
2877 std::string s(locName);
2878 return std::find(v.begin(),v.end(),s)!=v.end();
2881 std::vector< std::vector<int> > MEDFileFieldGlobs::whichAreEqualProfiles() const
2883 std::map<int,std::vector<int> > m;
2885 for(std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::const_iterator it=_pfls.begin();it!=_pfls.end();it++,i++)
2887 const DataArrayInt *tmp=(*it);
2890 m[tmp->getHashCode()].push_back(i);
2893 std::vector< std::vector<int> > ret;
2894 for(std::map<int,std::vector<int> >::const_iterator it2=m.begin();it2!=m.end();it2++)
2896 if((*it2).second.size()>1)
2898 std::vector<int> ret0;
2899 bool equalityOrNot=false;
2900 for(std::vector<int>::const_iterator it3=(*it2).second.begin();it3!=(*it2).second.end();it3++)
2902 std::vector<int>::const_iterator it4=it3; it4++;
2903 for(;it4!=(*it2).second.end();it4++)
2905 if(_pfls[*it3]->isEqualWithoutConsideringStr(*_pfls[*it4]))
2908 ret0.push_back(*it3);
2909 ret0.push_back(*it4);
2915 ret.push_back(ret0);
2921 std::vector< std::vector<int> > MEDFileFieldGlobs::whichAreEqualLocs(double eps) const
2923 throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::whichAreEqualLocs : no implemented yet ! Sorry !");
2926 void MEDFileFieldGlobs::appendProfile(DataArrayInt *pfl)
2928 std::string name(pfl->getName());
2930 throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::appendProfile : unsupported profiles with no name !");
2931 for(std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::const_iterator it=_pfls.begin();it!=_pfls.end();it++)
2932 if(name==(*it)->getName())
2934 if(!pfl->isEqual(*(*it)))
2936 std::ostringstream oss; oss << "MEDFileFieldGlobs::appendProfile : profile \"" << name << "\" already exists and is different from existing !";
2937 throw INTERP_KERNEL::Exception(oss.str().c_str());
2941 _pfls.push_back(pfl);
2944 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)
2946 std::string name(locName);
2948 throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::appendLoc : unsupported localizations with no name !");
2949 MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> obj=MEDFileFieldLoc::New(locName,geoType,refCoo,gsCoo,w);
2950 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFieldLoc> >::const_iterator it=_locs.begin();it!=_locs.end();it++)
2951 if((*it)->isName(locName))
2953 if(!(*it)->isEqual(*obj,1e-12))
2955 std::ostringstream oss; oss << "MEDFileFieldGlobs::appendLoc : localization \"" << name << "\" already exists and is different from existing !";
2956 throw INTERP_KERNEL::Exception(oss.str().c_str());
2959 _locs.push_back(obj);
2962 std::string MEDFileFieldGlobs::createNewNameOfPfl() const
2964 std::vector<std::string> names=getPfls();
2965 return CreateNewNameNotIn("NewPfl_",names);
2968 std::string MEDFileFieldGlobs::createNewNameOfLoc() const
2970 std::vector<std::string> names=getLocs();
2971 return CreateNewNameNotIn("NewLoc_",names);
2974 std::string MEDFileFieldGlobs::CreateNewNameNotIn(const std::string& prefix, const std::vector<std::string>& namesToAvoid)
2976 for(std::size_t sz=0;sz<100000;sz++)
2978 std::ostringstream tryName;
2979 tryName << prefix << sz;
2980 if(std::find(namesToAvoid.begin(),namesToAvoid.end(),tryName.str())==namesToAvoid.end())
2981 return tryName.str();
2983 throw INTERP_KERNEL::Exception("MEDFileFieldGlobs::CreateNewNameNotIn : impossible to create an additional profile limit of 100000 profiles reached !");
2987 * Creates a MEDFileFieldGlobsReal on a given file name. Nothing is read here.
2988 * \param [in] fname - the file name.
2990 MEDFileFieldGlobsReal::MEDFileFieldGlobsReal(const std::string& fname):_globals(MEDFileFieldGlobs::New(fname))
2995 * Creates an empty MEDFileFieldGlobsReal.
2997 MEDFileFieldGlobsReal::MEDFileFieldGlobsReal():_globals(MEDFileFieldGlobs::New())
3001 std::size_t MEDFileFieldGlobsReal::getHeapMemorySizeWithoutChildren() const
3006 std::vector<const BigMemoryObject *> MEDFileFieldGlobsReal::getDirectChildren() const
3008 std::vector<const BigMemoryObject *> ret;
3009 if((const MEDFileFieldGlobs *)_globals)
3010 ret.push_back((const MEDFileFieldGlobs *)_globals);
3015 * Returns a string describing profiles and Gauss points held in \a this.
3016 * \return std::string - the description string.
3018 void MEDFileFieldGlobsReal::simpleReprGlobs(std::ostream& oss) const
3020 const MEDFileFieldGlobs *glob=_globals;
3021 std::ostringstream oss2; oss2 << glob;
3022 std::string stars(oss2.str().length(),'*');
3023 oss << "Globals information on fields (at " << oss2.str() << "):" << "\n************************************" << stars << "\n\n";
3025 glob->simpleRepr(oss);
3027 oss << "NO GLOBAL INFORMATION !\n";
3030 void MEDFileFieldGlobsReal::resetContent()
3032 _globals=MEDFileFieldGlobs::New();
3035 MEDFileFieldGlobsReal::~MEDFileFieldGlobsReal()
3040 * Copies references to profiles and Gauss points from another MEDFileFieldGlobsReal.
3041 * \param [in] other - the other MEDFileFieldGlobsReal to copy data from.
3043 void MEDFileFieldGlobsReal::shallowCpyGlobs(const MEDFileFieldGlobsReal& other)
3045 _globals=other._globals;
3049 * Copies references to ** only used ** by \a this, profiles and Gauss points from another MEDFileFieldGlobsReal.
3050 * \param [in] other - the other MEDFileFieldGlobsReal to copy data from.
3052 void MEDFileFieldGlobsReal::shallowCpyOnlyUsedGlobs(const MEDFileFieldGlobsReal& other)
3054 const MEDFileFieldGlobs *otherg(other._globals);
3057 _globals=otherg->shallowCpyPart(getPflsReallyUsed(),getLocsReallyUsed());
3061 * Copies deeply to ** only used ** by \a this, profiles and Gauss points from another MEDFileFieldGlobsReal.
3062 * \param [in] other - the other MEDFileFieldGlobsReal to copy data from.
3064 void MEDFileFieldGlobsReal::deepCpyOnlyUsedGlobs(const MEDFileFieldGlobsReal& other)
3066 const MEDFileFieldGlobs *otherg(other._globals);
3069 _globals=otherg->deepCpyPart(getPflsReallyUsed(),getLocsReallyUsed());
3072 void MEDFileFieldGlobsReal::deepCpyGlobs(const MEDFileFieldGlobsReal& other)
3074 _globals=other._globals;
3075 if((const MEDFileFieldGlobs *)_globals)
3076 _globals=other._globals->deepCpy();
3080 * Adds profiles and Gauss points held by another MEDFileFieldGlobsReal to \a this one.
3081 * \param [in] other - the MEDFileFieldGlobsReal to copy data from.
3082 * \param [in] eps - a precision used to compare Gauss points with same name held by
3083 * \a this and \a other MEDFileFieldGlobsReal.
3084 * \throw If \a this and \a other hold profiles with equal names but different ids.
3085 * \throw If \a this and \a other hold different Gauss points with equal names.
3087 void MEDFileFieldGlobsReal::appendGlobs(const MEDFileFieldGlobsReal& other, double eps)
3089 const MEDFileFieldGlobs *thisGlobals(_globals),*otherGlobals(other._globals);
3090 if(thisGlobals==otherGlobals)
3094 _globals=other._globals;
3097 _globals->appendGlobs(*other._globals,eps);
3100 void MEDFileFieldGlobsReal::checkGlobsCoherency() const
3102 checkGlobsPflsPartCoherency();
3103 checkGlobsLocsPartCoherency();
3106 void MEDFileFieldGlobsReal::checkGlobsPflsPartCoherency() const
3108 contentNotNull()->checkGlobsPflsPartCoherency(getPflsReallyUsed());
3111 void MEDFileFieldGlobsReal::checkGlobsLocsPartCoherency() const
3113 contentNotNull()->checkGlobsLocsPartCoherency(getLocsReallyUsed());
3116 void MEDFileFieldGlobsReal::loadProfileInFile(med_idt fid, int id, const std::string& pflName)
3118 contentNotNull()->loadProfileInFile(fid,id,pflName);
3121 void MEDFileFieldGlobsReal::loadProfileInFile(med_idt fid, int id)
3123 contentNotNull()->loadProfileInFile(fid,id);
3126 void MEDFileFieldGlobsReal::loadGlobals(med_idt fid)
3128 contentNotNull()->loadGlobals(fid,*this);
3131 void MEDFileFieldGlobsReal::loadAllGlobals(med_idt fid)
3133 contentNotNull()->loadAllGlobals(fid);
3136 void MEDFileFieldGlobsReal::writeGlobals(med_idt fid, const MEDFileWritable& opt) const
3138 contentNotNull()->writeGlobals(fid,opt);
3142 * Returns names of all profiles. To get only used profiles call getPflsReallyUsed()
3143 * or getPflsReallyUsedMulti().
3144 * \return std::vector<std::string> - a sequence of names of all profiles.
3146 std::vector<std::string> MEDFileFieldGlobsReal::getPfls() const
3148 return contentNotNull()->getPfls();
3152 * Returns names of all localizations. To get only used localizations call getLocsReallyUsed()
3153 * or getLocsReallyUsedMulti().
3154 * \return std::vector<std::string> - a sequence of names of all localizations.
3156 std::vector<std::string> MEDFileFieldGlobsReal::getLocs() const
3158 return contentNotNull()->getLocs();
3162 * Checks if the profile with a given name exists.
3163 * \param [in] pflName - the profile name of interest.
3164 * \return bool - \c true if the profile named \a pflName exists.
3166 bool MEDFileFieldGlobsReal::existsPfl(const std::string& pflName) const
3168 return contentNotNull()->existsPfl(pflName);
3172 * Checks if the localization with a given name exists.
3173 * \param [in] locName - the localization name of interest.
3174 * \return bool - \c true if the localization named \a locName exists.
3176 bool MEDFileFieldGlobsReal::existsLoc(const std::string& locName) const
3178 return contentNotNull()->existsLoc(locName);
3181 std::string MEDFileFieldGlobsReal::createNewNameOfPfl() const
3183 return contentNotNull()->createNewNameOfPfl();
3186 std::string MEDFileFieldGlobsReal::createNewNameOfLoc() const
3188 return contentNotNull()->createNewNameOfLoc();
3192 * Sets the name of a MED file.
3193 * \param [inout] fileName - the file name.
3195 void MEDFileFieldGlobsReal::setFileName(const std::string& fileName)
3197 contentNotNull()->setFileName(fileName);
3201 * Finds equal profiles. Two profiles are considered equal if they contain the same ids
3202 * in the same order.
3203 * \return std::vector< std::vector<int> > - a sequence of groups of equal profiles.
3204 * Each item of this sequence is a vector containing ids of equal profiles.
3206 std::vector< std::vector<int> > MEDFileFieldGlobsReal::whichAreEqualProfiles() const
3208 return contentNotNull()->whichAreEqualProfiles();
3212 * Finds equal localizations.
3213 * \param [in] eps - a precision used to compare real values of the localizations.
3214 * \return std::vector< std::vector<int> > - a sequence of groups of equal localizations.
3215 * Each item of this sequence is a vector containing ids of equal localizations.
3217 std::vector< std::vector<int> > MEDFileFieldGlobsReal::whichAreEqualLocs(double eps) const
3219 return contentNotNull()->whichAreEqualLocs(eps);
3223 * Renames the profiles. References to profiles (a reference is a profile name) are not changed.
3224 * \param [in] mapOfModif - a sequence describing required renaming. Each element of
3225 * this sequence is a pair whose
3226 * - the first item is a vector of profile names to replace by the second item,
3227 * - the second item is a profile name to replace every profile name of the first item.
3229 void MEDFileFieldGlobsReal::changePflsNamesInStruct(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
3231 contentNotNull()->changePflsNamesInStruct(mapOfModif);
3235 * Renames the localizations. References to localizations (a reference is a localization name) are not changed.
3236 * \param [in] mapOfModif - a sequence describing required renaming. Each element of
3237 * this sequence is a pair whose
3238 * - the first item is a vector of localization names to replace by the second item,
3239 * - the second item is a localization name to replace every localization name of the first item.
3241 void MEDFileFieldGlobsReal::changeLocsNamesInStruct(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
3243 contentNotNull()->changeLocsNamesInStruct(mapOfModif);
3247 * Replaces references to some profiles (a reference is a profile name) by references
3248 * to other profiles and, contrary to changePflsRefsNamesGen(), renames the profiles
3249 * them-selves accordingly. <br>
3250 * This method is a generalization of changePflName().
3251 * \param [in] mapOfModif - a sequence describing required replacements. Each element of
3252 * this sequence is a pair whose
3253 * - the first item is a vector of profile names to replace by the second item,
3254 * - the second item is a profile name to replace every profile of the first item.
3255 * \sa changePflsRefsNamesGen()
3256 * \sa changePflName()
3258 void MEDFileFieldGlobsReal::changePflsNames(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
3260 changePflsRefsNamesGen(mapOfModif);
3261 changePflsNamesInStruct(mapOfModif);
3265 * Replaces references to some localizations (a reference is a localization name) by references
3266 * to other localizations and, contrary to changeLocsRefsNamesGen(), renames the localizations
3267 * them-selves accordingly. <br>
3268 * This method is a generalization of changeLocName().
3269 * \param [in] mapOfModif - a sequence describing required replacements. Each element of
3270 * this sequence is a pair whose
3271 * - the first item is a vector of localization names to replace by the second item,
3272 * - the second item is a localization name to replace every localization of the first item.
3273 * \sa changeLocsRefsNamesGen()
3274 * \sa changeLocName()
3276 void MEDFileFieldGlobsReal::changeLocsNames(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
3278 changeLocsRefsNamesGen(mapOfModif);
3279 changeLocsNamesInStruct(mapOfModif);
3283 * Renames the profile having a given name and updates references to this profile.
3284 * \param [in] oldName - the name of the profile to rename.
3285 * \param [in] newName - a new name of the profile.
3286 * \sa changePflsNames().
3288 void MEDFileFieldGlobsReal::changePflName(const std::string& oldName, const std::string& newName)
3290 std::vector< std::pair<std::vector<std::string>, std::string > > mapOfModif(1);
3291 std::pair<std::vector<std::string>, std::string > p(std::vector<std::string>(1,std::string(oldName)),std::string(newName));
3293 changePflsNames(mapOfModif);
3297 * Renames the localization having a given name and updates references to this localization.
3298 * \param [in] oldName - the name of the localization to rename.
3299 * \param [in] newName - a new name of the localization.
3300 * \sa changeLocsNames().
3302 void MEDFileFieldGlobsReal::changeLocName(const std::string& oldName, const std::string& newName)
3304 std::vector< std::pair<std::vector<std::string>, std::string > > mapOfModif(1);
3305 std::pair<std::vector<std::string>, std::string > p(std::vector<std::string>(1,std::string(oldName)),std::string(newName));
3307 changeLocsNames(mapOfModif);
3311 * Removes duplicated profiles. Returns a map used to update references to removed
3312 * profiles via changePflsRefsNamesGen().
3313 * Equal profiles are found using whichAreEqualProfiles().
3314 * \return std::vector< std::pair<std::vector<std::string>, std::string > > -
3315 * a sequence describing the performed replacements of profiles. Each element of
3316 * this sequence is a pair whose
3317 * - the first item is a vector of profile names replaced by the second item,
3318 * - the second item is a profile name replacing every profile of the first item.
3320 std::vector< std::pair<std::vector<std::string>, std::string > > MEDFileFieldGlobsReal::zipPflsNames()
3322 std::vector< std::vector<int> > pseudoRet=whichAreEqualProfiles();
3323 std::vector< std::pair<std::vector<std::string>, std::string > > ret(pseudoRet.size());
3325 for(std::vector< std::vector<int> >::const_iterator it=pseudoRet.begin();it!=pseudoRet.end();it++,i++)
3327 std::vector< std::string > tmp((*it).size());
3329 for(std::vector<int>::const_iterator it2=(*it).begin();it2!=(*it).end();it2++,j++)
3330 tmp[j]=std::string(getProfileFromId(*it2)->getName());
3331 std::pair<std::vector<std::string>, std::string > p(tmp,tmp.front());
3333 std::vector<int> tmp2((*it).begin()+1,(*it).end());
3334 killProfileIds(tmp2);
3336 changePflsRefsNamesGen(ret);
3341 * Removes duplicated localizations. Returns a map used to update references to removed
3342 * localizations via changeLocsRefsNamesGen().
3343 * Equal localizations are found using whichAreEqualLocs().
3344 * \param [in] eps - a precision used to compare real values of the localizations.
3345 * \return std::vector< std::pair<std::vector<std::string>, std::string > > -
3346 * a sequence describing the performed replacements of localizations. Each element of
3347 * this sequence is a pair whose
3348 * - the first item is a vector of localization names replaced by the second item,
3349 * - the second item is a localization name replacing every localization of the first item.
3351 std::vector< std::pair<std::vector<std::string>, std::string > > MEDFileFieldGlobsReal::zipLocsNames(double eps)
3353 std::vector< std::vector<int> > pseudoRet=whichAreEqualLocs(eps);
3354 std::vector< std::pair<std::vector<std::string>, std::string > > ret(pseudoRet.size());
3356 for(std::vector< std::vector<int> >::const_iterator it=pseudoRet.begin();it!=pseudoRet.end();it++,i++)
3358 std::vector< std::string > tmp((*it).size());
3360 for(std::vector<int>::const_iterator it2=(*it).begin();it2!=(*it).end();it2++,j++)
3361 tmp[j]=std::string(getLocalizationFromId(*it2).getName());
3362 std::pair<std::vector<std::string>, std::string > p(tmp,tmp.front());
3364 std::vector<int> tmp2((*it).begin()+1,(*it).end());
3365 killLocalizationIds(tmp2);
3367 changeLocsRefsNamesGen(ret);
3372 * Returns number of Gauss points per cell in a given localization.
3373 * \param [in] locId - an id of the localization of interest.
3374 * \return int - the number of the Gauss points per cell.
3376 int MEDFileFieldGlobsReal::getNbOfGaussPtPerCell(int locId) const
3378 return contentNotNull()->getNbOfGaussPtPerCell(locId);
3382 * Returns an id of a localization by its name.
3383 * \param [in] loc - the localization name of interest.
3384 * \return int - the id of the localization.
3385 * \throw If there is no a localization named \a loc.
3387 int MEDFileFieldGlobsReal::getLocalizationId(const std::string& loc) const
3389 return contentNotNull()->getLocalizationId(loc);
3393 * Returns the name of the MED file.
3394 * \return const std::string& - the MED file name.
3396 std::string MEDFileFieldGlobsReal::getFileName() const
3398 return contentNotNull()->getFileName();
3402 * Returns a localization object by its name.
3403 * \param [in] locName - the name of the localization of interest.
3404 * \return const MEDFileFieldLoc& - the localization object having the name \a locName.
3405 * \throw If there is no a localization named \a locName.
3407 const MEDFileFieldLoc& MEDFileFieldGlobsReal::getLocalization(const std::string& locName) const
3409 return contentNotNull()->getLocalization(locName);
3413 * Returns a localization object by its id.
3414 * \param [in] locId - the id of the localization of interest.
3415 * \return const MEDFileFieldLoc& - the localization object having the id \a locId.
3416 * \throw If there is no a localization with id \a locId.
3418 const MEDFileFieldLoc& MEDFileFieldGlobsReal::getLocalizationFromId(int locId) const
3420 return contentNotNull()->getLocalizationFromId(locId);
3424 * Returns a profile array by its name.
3425 * \param [in] pflName - the name of the profile of interest.
3426 * \return const DataArrayInt * - the profile array having the name \a pflName.
3427 * \throw If there is no a profile named \a pflName.
3429 const DataArrayInt *MEDFileFieldGlobsReal::getProfile(const std::string& pflName) const
3431 return contentNotNull()->getProfile(pflName);
3435 * Returns a profile array by its id.
3436 * \param [in] pflId - the id of the profile of interest.
3437 * \return const DataArrayInt * - the profile array having the id \a pflId.
3438 * \throw If there is no a profile with id \a pflId.
3440 const DataArrayInt *MEDFileFieldGlobsReal::getProfileFromId(int pflId) const
3442 return contentNotNull()->getProfileFromId(pflId);
3446 * Returns a localization object, apt for modification, by its id.
3447 * \param [in] locId - the id of the localization of interest.
3448 * \return MEDFileFieldLoc& - a non-const reference to the localization object
3449 * having the id \a locId.
3450 * \throw If there is no a localization with id \a locId.
3452 MEDFileFieldLoc& MEDFileFieldGlobsReal::getLocalizationFromId(int locId)
3454 return contentNotNull()->getLocalizationFromId(locId);
3458 * Returns a localization object, apt for modification, by its name.
3459 * \param [in] locName - the name of the localization of interest.
3460 * \return MEDFileFieldLoc& - a non-const reference to the localization object
3461 * having the name \a locName.
3462 * \throw If there is no a localization named \a locName.
3464 MEDFileFieldLoc& MEDFileFieldGlobsReal::getLocalization(const std::string& locName)
3466 return contentNotNull()->getLocalization(locName);
3470 * Returns a profile array, apt for modification, by its name.
3471 * \param [in] pflName - the name of the profile of interest.
3472 * \return DataArrayInt * - a non-const pointer to the profile array having the name \a pflName.
3473 * \throw If there is no a profile named \a pflName.
3475 DataArrayInt *MEDFileFieldGlobsReal::getProfile(const std::string& pflName)
3477 return contentNotNull()->getProfile(pflName);
3481 * Returns a profile array, apt for modification, by its id.
3482 * \param [in] pflId - the id of the profile of interest.
3483 * \return DataArrayInt * - a non-const pointer to the profile array having the id \a pflId.
3484 * \throw If there is no a profile with id \a pflId.
3486 DataArrayInt *MEDFileFieldGlobsReal::getProfileFromId(int pflId)
3488 return contentNotNull()->getProfileFromId(pflId);
3492 * Removes profiles given by their ids. No data is updated to track this removal.
3493 * \param [in] pflIds - a sequence of ids of the profiles to remove.
3495 void MEDFileFieldGlobsReal::killProfileIds(const std::vector<int>& pflIds)
3497 contentNotNull()->killProfileIds(pflIds);
3501 * Removes localizations given by their ids. No data is updated to track this removal.
3502 * \param [in] locIds - a sequence of ids of the localizations to remove.
3504 void MEDFileFieldGlobsReal::killLocalizationIds(const std::vector<int>& locIds)
3506 contentNotNull()->killLocalizationIds(locIds);
3510 * Stores a profile array.
3511 * \param [in] pfl - the profile array to store.
3512 * \throw If the name of \a pfl is empty.
3513 * \throw If a profile with the same name as that of \a pfl already exists but contains
3516 void MEDFileFieldGlobsReal::appendProfile(DataArrayInt *pfl)
3518 contentNotNull()->appendProfile(pfl);
3522 * Adds a new localization of Gauss points.
3523 * \param [in] locName - the name of the new localization.
3524 * \param [in] geoType - a geometrical type of the reference cell.
3525 * \param [in] refCoo - coordinates of points of the reference cell. Size of this vector
3526 * must be \c nbOfNodesPerCell * \c dimOfType.
3527 * \param [in] gsCoo - coordinates of Gauss points on the reference cell. Size of this vector
3528 * must be _wg_.size() * \c dimOfType.
3529 * \param [in] w - the weights of Gauss points.
3530 * \throw If \a locName is empty.
3531 * \throw If a localization with the name \a locName already exists but is
3532 * different form the new one.
3534 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)
3536 contentNotNull()->appendLoc(locName,geoType,refCoo,gsCoo,w);
3539 MEDFileFieldGlobs *MEDFileFieldGlobsReal::contentNotNull()
3541 MEDFileFieldGlobs *g(_globals);
3543 throw INTERP_KERNEL::Exception("MEDFileFieldGlobsReal::contentNotNull : no content in not const !");
3547 const MEDFileFieldGlobs *MEDFileFieldGlobsReal::contentNotNull() const
3549 const MEDFileFieldGlobs *g(_globals);
3551 throw INTERP_KERNEL::Exception("MEDFileFieldGlobsReal::contentNotNull : no content in const !");
3555 //= MEDFileFieldNameScope
3557 MEDFileFieldNameScope::MEDFileFieldNameScope()
3561 MEDFileFieldNameScope::MEDFileFieldNameScope(const std::string& fieldName):_name(fieldName)
3566 * Returns the name of \a this field.
3567 * \return std::string - a string containing the field name.
3569 std::string MEDFileFieldNameScope::getName() const
3575 * Sets name of \a this field
3576 * \param [in] name - the new field name.
3578 void MEDFileFieldNameScope::setName(const std::string& fieldName)
3583 std::string MEDFileFieldNameScope::getDtUnit() const
3588 void MEDFileFieldNameScope::setDtUnit(const std::string& dtUnit)
3593 void MEDFileFieldNameScope::copyNameScope(const MEDFileFieldNameScope& other)
3596 _dt_unit=other._dt_unit;
3599 //= MEDFileAnyTypeField1TSWithoutSDA
3601 void MEDFileAnyTypeField1TSWithoutSDA::deepCpyLeavesFrom(const MEDFileAnyTypeField1TSWithoutSDA& other)
3603 _field_per_mesh.resize(other._field_per_mesh.size());
3605 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=other._field_per_mesh.begin();it!=other._field_per_mesh.end();it++,i++)
3607 if((const MEDFileFieldPerMesh *)*it)
3608 _field_per_mesh[i]=(*it)->deepCpy(this);
3613 * Prints a string describing \a this field into a stream. This string is outputted
3614 * by \c print Python command.
3615 * \param [in] bkOffset - number of white spaces printed at the beginning of each line.
3616 * \param [in,out] oss - the out stream.
3617 * \param [in] f1tsId - the field index within a MED file. If \a f1tsId < 0, the tiny
3618 * info id printed, else, not.
3620 void MEDFileAnyTypeField1TSWithoutSDA::simpleRepr(int bkOffset, std::ostream& oss, int f1tsId) const
3622 std::string startOfLine(bkOffset,' ');
3623 oss << startOfLine << "Field ";
3625 oss << "[Type=" << getTypeStr() << "] with name \"" << getName() << "\" ";
3626 oss << "on one time Step ";
3628 oss << "(" << f1tsId << ") ";
3629 oss << "on iteration=" << _iteration << " order=" << _order << "." << std::endl;
3630 oss << startOfLine << "Time attached is : " << _dt << " [" << _dt_unit << "]." << std::endl;
3631 const DataArray *arr=getUndergroundDataArray();
3634 const std::vector<std::string> &comps=arr->getInfoOnComponents();
3637 oss << startOfLine << "Field has " << comps.size() << " components with the following infos :" << std::endl;
3638 for(std::vector<std::string>::const_iterator it=comps.begin();it!=comps.end();it++)
3639 oss << startOfLine << " - \"" << (*it) << "\"" << std::endl;
3641 if(arr->isAllocated())
3643 oss << startOfLine << "Whole field contains " << arr->getNumberOfTuples() << " tuples." << std::endl;
3646 oss << startOfLine << "The array of the current field has not allocated yet !" << std::endl;
3650 oss << startOfLine << "Field infos are empty ! Not defined yet !" << std::endl;
3652 oss << startOfLine << "----------------------" << std::endl;
3653 if(!_field_per_mesh.empty())
3656 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it2=_field_per_mesh.begin();it2!=_field_per_mesh.end();it2++,i++)
3658 const MEDFileFieldPerMesh *cur=(*it2);
3660 cur->simpleRepr(bkOffset,oss,i);
3662 oss << startOfLine << "Field per mesh #" << i << " is not defined !" << std::endl;
3667 oss << startOfLine << "Field is not defined on any meshes !" << std::endl;
3669 oss << startOfLine << "----------------------" << std::endl;
3672 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > MEDFileAnyTypeField1TSWithoutSDA::splitComponents() const
3674 const DataArray *arr(getUndergroundDataArray());
3676 throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::splitComponents : no array defined !");
3677 int nbOfCompo=arr->getNumberOfComponents();
3678 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > ret(nbOfCompo);
3679 for(int i=0;i<nbOfCompo;i++)
3682 std::vector<int> v(1,i);
3683 MEDCouplingAutoRefCountObjectPtr<DataArray> arr2=arr->keepSelectedComponents(v);
3684 ret[i]->setArray(arr2);
3689 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)
3693 MEDFileAnyTypeField1TSWithoutSDA::MEDFileAnyTypeField1TSWithoutSDA():_iteration(-1),_order(-1),_dt(0.),_csit(-1),_nb_of_tuples_to_be_allocated(-1)
3698 * Returns the maximal dimension of supporting elements. Returns -2 if \a this is
3699 * empty. Returns -1 if this in on nodes.
3700 * \return int - the dimension of \a this.
3702 int MEDFileAnyTypeField1TSWithoutSDA::getDimension() const
3705 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3706 (*it)->getDimension(ret);
3711 * Returns the mesh name.
3712 * \return std::string - a string holding the mesh name.
3713 * \throw If \c _field_per_mesh.empty()
3715 std::string MEDFileAnyTypeField1TSWithoutSDA::getMeshName() const
3717 if(_field_per_mesh.empty())
3718 throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::getMeshName : No field set !");
3719 return _field_per_mesh[0]->getMeshName();
3722 void MEDFileAnyTypeField1TSWithoutSDA::setMeshName(const std::string& newMeshName)
3724 std::string oldName(getMeshName());
3725 std::vector< std::pair<std::string,std::string> > v(1);
3726 v[0].first=oldName; v[0].second=newMeshName;
3730 bool MEDFileAnyTypeField1TSWithoutSDA::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab)
3733 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3735 MEDFileFieldPerMesh *cur(*it);
3737 ret=cur->changeMeshNames(modifTab) || ret;
3743 * Returns the number of iteration of the state of underlying mesh.
3744 * \return int - the iteration number.
3745 * \throw If \c _field_per_mesh.empty()
3747 int MEDFileAnyTypeField1TSWithoutSDA::getMeshIteration() const
3749 if(_field_per_mesh.empty())
3750 throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::getMeshIteration : No field set !");
3751 return _field_per_mesh[0]->getMeshIteration();
3755 * Returns the order number of iteration of the state of underlying mesh.
3756 * \return int - the order number.
3757 * \throw If \c _field_per_mesh.empty()
3759 int MEDFileAnyTypeField1TSWithoutSDA::getMeshOrder() const
3761 if(_field_per_mesh.empty())
3762 throw INTERP_KERNEL::Exception("MEDFileFieldPerMeshPerTypePerDisc::getMeshOrder : No field set !");
3763 return _field_per_mesh[0]->getMeshOrder();
3767 * Checks if \a this field is tagged by a given iteration number and a given
3768 * iteration order number.
3769 * \param [in] iteration - the iteration number of interest.
3770 * \param [in] order - the iteration order number of interest.
3771 * \return bool - \c true if \a this->getIteration() == \a iteration &&
3772 * \a this->getOrder() == \a order.
3774 bool MEDFileAnyTypeField1TSWithoutSDA::isDealingTS(int iteration, int order) const
3776 return iteration==_iteration && order==_order;
3780 * Returns number of iteration and order number of iteration when
3781 * \a this field has been calculated.
3782 * \return std::pair<int,int> - a pair of the iteration number and the iteration
3785 std::pair<int,int> MEDFileAnyTypeField1TSWithoutSDA::getDtIt() const
3787 std::pair<int,int> p;
3793 * Returns number of iteration and order number of iteration when
3794 * \a this field has been calculated.
3795 * \param [in,out] p - a pair returning the iteration number and the iteration
3798 void MEDFileAnyTypeField1TSWithoutSDA::fillIteration(std::pair<int,int>& p) const
3805 * Returns all types of spatial discretization of \a this field.
3806 * \param [in,out] types - a sequence of types of \a this field.
3808 void MEDFileAnyTypeField1TSWithoutSDA::fillTypesOfFieldAvailable(std::vector<TypeOfField>& types) const
3810 std::set<TypeOfField> types2;
3811 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3813 (*it)->fillTypesOfFieldAvailable(types2);
3815 std::back_insert_iterator< std::vector<TypeOfField> > bi(types);
3816 std::copy(types2.begin(),types2.end(),bi);
3820 * Returns all types of spatial discretization of \a this field.
3821 * \return std::vector<TypeOfField> - a sequence of types of spatial discretization
3824 std::vector<TypeOfField> MEDFileAnyTypeField1TSWithoutSDA::getTypesOfFieldAvailable() const
3826 std::vector<TypeOfField> ret;
3827 fillTypesOfFieldAvailable(ret);
3831 std::vector<std::string> MEDFileAnyTypeField1TSWithoutSDA::getPflsReallyUsed2() const
3833 std::vector<std::string> ret;
3834 std::set<std::string> ret2;
3835 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3837 std::vector<std::string> tmp=(*it)->getPflsReallyUsed();
3838 for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
3839 if(ret2.find(*it2)==ret2.end())
3841 ret.push_back(*it2);
3848 std::vector<std::string> MEDFileAnyTypeField1TSWithoutSDA::getLocsReallyUsed2() const
3850 std::vector<std::string> ret;
3851 std::set<std::string> ret2;
3852 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3854 std::vector<std::string> tmp=(*it)->getLocsReallyUsed();
3855 for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
3856 if(ret2.find(*it2)==ret2.end())
3858 ret.push_back(*it2);
3865 std::vector<std::string> MEDFileAnyTypeField1TSWithoutSDA::getPflsReallyUsedMulti2() const
3867 std::vector<std::string> ret;
3868 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3870 std::vector<std::string> tmp=(*it)->getPflsReallyUsedMulti();
3871 ret.insert(ret.end(),tmp.begin(),tmp.end());
3876 std::vector<std::string> MEDFileAnyTypeField1TSWithoutSDA::getLocsReallyUsedMulti2() const
3878 std::vector<std::string> ret;
3879 std::set<std::string> ret2;
3880 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3882 std::vector<std::string> tmp=(*it)->getLocsReallyUsedMulti();
3883 ret.insert(ret.end(),tmp.begin(),tmp.end());
3888 void MEDFileAnyTypeField1TSWithoutSDA::changePflsRefsNamesGen2(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
3890 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3891 (*it)->changePflsRefsNamesGen(mapOfModif);
3894 void MEDFileAnyTypeField1TSWithoutSDA::changeLocsRefsNamesGen2(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
3896 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
3897 (*it)->changeLocsRefsNamesGen(mapOfModif);
3901 * Returns all attributes of parts of \a this field lying on a given mesh.
3902 * Each part differs from other ones by a type of supporting mesh entity. The _i_-th
3903 * item of every of returned sequences refers to the _i_-th part of \a this field.
3904 * Thus all sequences returned by this method are of the same length equal to number
3905 * of different types of supporting entities.<br>
3906 * A field part can include sub-parts with several different spatial discretizations,
3907 * \ref ParaMEDMEM::ON_CELLS "ON_CELLS" and \ref ParaMEDMEM::ON_GAUSS_PT "ON_GAUSS_PT"
3908 * for example. Hence, some of the returned sequences contains nested sequences, and an item
3909 * of a nested sequence corresponds to a type of spatial discretization.<br>
3910 * This method allows for iteration over MEDFile DataStructure without any overhead.
3911 * \param [in] mname - a name of a mesh of interest. It can be \c NULL, which is valid
3912 * for the case with only one underlying mesh. (Actually, the number of meshes is
3913 * not checked if \a mname == \c NULL).
3914 * \param [in,out] types - a sequence of types of underlying mesh entities. A type per
3915 * a field part is returned.
3916 * \param [in,out] typesF - a sequence of sequences of types of spatial discretizations.
3917 * This sequence is of the same length as \a types.
3918 * \param [in,out] pfls - a sequence returning a profile name per each type of spatial
3919 * discretization. A profile name can be empty.
3920 * Length of this and of nested sequences is the same as that of \a typesF.
3921 * \param [in,out] locs - a sequence returning a localization name per each type of spatial
3922 * discretization. A localization name can be empty.
3923 * Length of this and of nested sequences is the same as that of \a typesF.
3924 * \return std::vector< std::vector< std::pair<int,int> > > - a sequence holding a range
3925 * of ids of tuples within the data array, per each type of spatial
3926 * discretization within one mesh entity type.
3927 * Length of this and of nested sequences is the same as that of \a typesF.
3928 * \throw If no field is lying on \a mname.
3930 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
3934 meshId=getMeshIdFromMeshName(mname);
3936 if(_field_per_mesh.empty())
3937 throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getFieldSplitedByType : This is empty !");
3938 return _field_per_mesh[meshId]->getFieldSplitedByType(types,typesF,pfls,locs);
3942 * Returns dimensions of mesh elements \a this field lies on. The returned value is a
3943 * maximal absolute dimension and values returned via the out parameter \a levs are
3944 * dimensions relative to the maximal absolute dimension. <br>
3945 * This method is designed for MEDFileField1TS instances that have a discretization
3946 * \ref ParaMEDMEM::ON_CELLS "ON_CELLS",
3947 * \ref ParaMEDMEM::ON_GAUSS_PT "ON_GAUSS_PT",
3948 * \ref ParaMEDMEM::ON_GAUSS_NE "ON_GAUSS_NE".
3949 * Only these 3 discretizations will be taken into account here. If \a this is
3950 * \ref ParaMEDMEM::ON_NODES "ON_NODES", -1 is returned and \a levs are empty.<br>
3951 * This method is useful to make the link between the dimension of the underlying mesh
3952 * and the levels of \a this, because it is possible that the highest dimension of \a this
3953 * field is not equal to the dimension of the underlying mesh.
3955 * Let's consider the following case:
3956 * - mesh \a m1 has a meshDimension 3 and has non empty levels [0,-1,-2] with elements
3957 * TETRA4, HEXA8, TRI3 and SEG2.
3958 * - field \a f1 lies on \a m1 and is defined on 3D and 1D elements TETRA4 and SEG2.
3959 * - field \a f2 lies on \a m1 and is defined on 2D and 1D elements TRI3 and SEG2.
3961 * In this case \a f1->getNonEmptyLevels() returns (3,[0,-2]) and \a
3962 * f2->getNonEmptyLevels() returns (2,[0,-1]). <br>
3963 * The returned values can be used for example to retrieve a MEDCouplingFieldDouble lying
3964 * on elements of a certain relative level by calling getFieldAtLevel(). \a meshDimRelToMax
3965 * parameter of getFieldAtLevel() is computed basing on the returned values as this:
3966 * <em> meshDimRelToMax = absDim - meshDim + relativeLev </em>.
3968 * to retrieve the highest level of
3969 * \a f1: <em>f1->getFieldAtLevel( ON_CELLS, 3-3+0 ); // absDim - meshDim + relativeLev</em><br>
3970 * to retrieve the lowest level of \a f1: <em>f1->getFieldAtLevel( ON_CELLS, 3-3+(-2) );</em><br>
3971 * to retrieve the highest level of \a f2: <em>f2->getFieldAtLevel( ON_CELLS, 2-3+0 );</em><br>
3972 * to retrieve the lowest level of \a f2: <em>f2->getFieldAtLevel( ON_CELLS, 2-3+(-1) )</em>.
3973 * \param [in] mname - a name of a mesh of interest. It can be \c NULL, which is valid
3974 * for the case with only one underlying mesh. (Actually, the number of meshes is
3975 * not checked if \a mname == \c NULL).
3976 * \param [in,out] levs - a sequence returning the dimensions relative to the maximal
3977 * absolute one. They are in decreasing order. This sequence is cleared before
3979 * \return int - the maximal absolute dimension of elements \a this fields lies on.
3980 * \throw If no field is lying on \a mname.
3982 int MEDFileAnyTypeField1TSWithoutSDA::getNonEmptyLevels(const std::string& mname, std::vector<int>& levs) const
3985 int meshId=getMeshIdFromMeshName(mname);
3986 std::vector<INTERP_KERNEL::NormalizedCellType> types;
3987 std::vector< std::vector<TypeOfField> > typesF;
3988 std::vector< std::vector<std::string> > pfls, locs;
3989 _field_per_mesh[meshId]->getFieldSplitedByType(types,typesF,pfls,locs);
3991 throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getNonEmptyLevels : 'this' is empty !");
3992 std::set<INTERP_KERNEL::NormalizedCellType> st(types.begin(),types.end());
3993 if(st.size()==1 && (*st.begin())==INTERP_KERNEL::NORM_ERROR)
3995 st.erase(INTERP_KERNEL::NORM_ERROR);
3997 for(std::set<INTERP_KERNEL::NormalizedCellType>::const_iterator it=st.begin();it!=st.end();it++)
3999 const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(*it);
4000 ret1.insert((int)cm.getDimension());
4002 int ret=*std::max_element(ret1.begin(),ret1.end());
4003 std::copy(ret1.rbegin(),ret1.rend(),std::back_insert_iterator<std::vector<int> >(levs));
4004 std::transform(levs.begin(),levs.end(),levs.begin(),std::bind2nd(std::plus<int>(),-ret));
4009 * \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.
4010 * \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.
4011 * \param [in] locId is the localization id to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set. It corresponds to the position of
4012 * \c pfls[std::distance(types.begin(),std::find(types.begin(),typ)] vector in MEDFileField1TSWithoutSDA::getFieldSplitedByType. For non gausspoints field users, the value is 0.
4014 MEDFileFieldPerMeshPerTypePerDisc *MEDFileAnyTypeField1TSWithoutSDA::getLeafGivenMeshAndTypeAndLocId(const std::string& mName, INTERP_KERNEL::NormalizedCellType typ, int locId)
4016 int mid=getMeshIdFromMeshName(mName);
4017 return _field_per_mesh[mid]->getLeafGivenTypeAndLocId(typ,locId);
4021 * \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.
4022 * \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.
4023 * \param [in] locId is the localization id to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set. It corresponds to the position of
4024 * \c pfls[std::distance(types.begin(),std::find(types.begin(),typ)] vector in MEDFileField1TSWithoutSDA::getFieldSplitedByType. For non gausspoints field users, the value is 0.
4026 const MEDFileFieldPerMeshPerTypePerDisc *MEDFileAnyTypeField1TSWithoutSDA::getLeafGivenMeshAndTypeAndLocId(const std::string& mName, INTERP_KERNEL::NormalizedCellType typ, int locId) const
4028 int mid=getMeshIdFromMeshName(mName);
4029 return _field_per_mesh[mid]->getLeafGivenTypeAndLocId(typ,locId);
4033 * \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.
4035 int MEDFileAnyTypeField1TSWithoutSDA::getMeshIdFromMeshName(const std::string& mName) const
4037 if(_field_per_mesh.empty())
4038 throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getMeshIdFromMeshName : No field set !");
4041 std::string mName2(mName);
4043 std::vector<std::string> msg;
4044 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++,ret++)
4045 if(mName2==(*it)->getMeshName())
4048 msg.push_back((*it)->getMeshName());
4049 std::ostringstream oss; oss << "MEDFileField1TSWithoutSDA::getMeshIdFromMeshName : No such mesh \"" << mName2 << "\" as underlying mesh of field \"" << getName() << "\" !\n";
4050 oss << "Possible meshes are : ";
4051 for(std::vector<std::string>::const_iterator it2=msg.begin();it2!=msg.end();it2++)
4052 oss << "\"" << (*it2) << "\" ";
4053 throw INTERP_KERNEL::Exception(oss.str().c_str());
4056 int MEDFileAnyTypeField1TSWithoutSDA::addNewEntryIfNecessary(const MEDCouplingMesh *mesh)
4059 throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::addNewEntryIfNecessary : input mesh is NULL !");
4060 std::string tmp(mesh->getName());
4062 throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::addNewEntryIfNecessary : empty mesh name ! unsupported by MED file !");
4063 std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();
4065 for(;it!=_field_per_mesh.end();it++,i++)
4067 if((*it)->getMeshName()==tmp)
4070 int sz=_field_per_mesh.size();
4071 _field_per_mesh.resize(sz+1);
4072 _field_per_mesh[sz]=MEDFileFieldPerMesh::New(this,mesh);
4076 bool MEDFileAnyTypeField1TSWithoutSDA::renumberEntitiesLyingOnMesh(const std::string& meshName, const std::vector<int>& oldCode, const std::vector<int>& newCode, const DataArrayInt *renumO2N,
4077 MEDFileFieldGlobsReal& glob)
4080 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4082 MEDFileFieldPerMesh *fpm(*it);
4084 ret=fpm->renumberEntitiesLyingOnMesh(meshName,oldCode,newCode,renumO2N,glob) || ret;
4089 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > MEDFileAnyTypeField1TSWithoutSDA::splitDiscretizations() const
4091 std::vector<INTERP_KERNEL::NormalizedCellType> types;
4092 std::vector< std::vector<TypeOfField> > typesF;
4093 std::vector< std::vector<std::string> > pfls,locs;
4094 std::vector< std::vector<std::pair<int,int> > > bgEnd=getFieldSplitedByType(getMeshName().c_str(),types,typesF,pfls,locs);
4095 std::set<TypeOfField> allEnt;
4096 for(std::vector< std::vector<TypeOfField> >::const_iterator it1=typesF.begin();it1!=typesF.end();it1++)
4097 for(std::vector<TypeOfField>::const_iterator it2=(*it1).begin();it2!=(*it1).end();it2++)
4098 allEnt.insert(*it2);
4099 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > ret(allEnt.size());
4100 std::set<TypeOfField>::const_iterator it3(allEnt.begin());
4101 for(std::size_t i=0;i<allEnt.size();i++,it3++)
4103 std::vector< std::pair<int,int> > its;
4104 ret[i]=shallowCpy();
4105 int newLgth=ret[i]->keepOnlySpatialDiscretization(*it3,its);
4106 ret[i]->updateData(newLgth,its);
4111 int MEDFileAnyTypeField1TSWithoutSDA::keepOnlySpatialDiscretization(TypeOfField tof, std::vector< std::pair<int,int> >& its)
4113 int globalCounter=0;
4114 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4115 (*it)->keepOnlySpatialDiscretization(tof,globalCounter,its);
4116 return globalCounter;
4119 void MEDFileAnyTypeField1TSWithoutSDA::updateData(int newLgth, const std::vector< std::pair<int,int> >& oldStartStops)
4121 if(_nb_of_tuples_to_be_allocated>=0)
4123 _nb_of_tuples_to_be_allocated=newLgth;
4124 const DataArray *oldArr(getUndergroundDataArray());
4127 MEDCouplingAutoRefCountObjectPtr<DataArray> newArr(createNewEmptyDataArrayInstance());
4128 newArr->setInfoAndChangeNbOfCompo(oldArr->getInfoOnComponents());
4130 _nb_of_tuples_to_be_allocated=newLgth;//force the _nb_of_tuples_to_be_allocated because setArray has been used specialy
4134 if(_nb_of_tuples_to_be_allocated==-1)
4136 if(_nb_of_tuples_to_be_allocated==-2 || _nb_of_tuples_to_be_allocated==-3)
4138 const DataArray *oldArr(getUndergroundDataArray());
4139 if(!oldArr || !oldArr->isAllocated())
4140 throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::updateData : internal error 1 !");
4141 MEDCouplingAutoRefCountObjectPtr<DataArray> newArr(createNewEmptyDataArrayInstance());
4142 newArr->alloc(newLgth,getNumberOfComponents());
4144 newArr->copyStringInfoFrom(*oldArr);
4146 for(std::vector< std::pair<int,int> >::const_iterator it=oldStartStops.begin();it!=oldStartStops.end();it++)
4148 if((*it).second<(*it).first)
4149 throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::updateData : the range in the leaves was invalid !");
4150 newArr->setContigPartOfSelectedValues2(pos,oldArr,(*it).first,(*it).second,1);
4151 pos+=(*it).second-(*it).first;
4156 throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::updateData : internal error 2 !");
4159 void MEDFileAnyTypeField1TSWithoutSDA::writeLL(med_idt fid, const MEDFileWritable& opts, const MEDFileFieldNameScope& nasc) const
4161 if(_field_per_mesh.empty())
4162 throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::writeLL : empty field !");
4163 if(_field_per_mesh.size()>1)
4164 throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::writeLL : In MED3.0 mode in writting mode only ONE underlying mesh supported !");
4165 _field_per_mesh[0]->copyOptionsFrom(opts);
4166 _field_per_mesh[0]->writeLL(fid,nasc);
4170 * 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.
4171 * If false is returned the memory allocation is not required.
4173 bool MEDFileAnyTypeField1TSWithoutSDA::allocIfNecessaryTheArrayToReceiveDataFromFile()
4175 if(_nb_of_tuples_to_be_allocated>=0)
4177 getOrCreateAndGetArray()->alloc(_nb_of_tuples_to_be_allocated,getNumberOfComponents());
4178 _nb_of_tuples_to_be_allocated=-2;
4181 if(_nb_of_tuples_to_be_allocated==-2 || _nb_of_tuples_to_be_allocated==-3)
4183 if(_nb_of_tuples_to_be_allocated==-1)
4184 throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::allocIfNecessaryTheArrayToReceiveDataFromFile : trying to read from a file an empty instance ! Need to prepare the structure before !");
4185 if(_nb_of_tuples_to_be_allocated<-3)
4186 throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::allocIfNecessaryTheArrayToReceiveDataFromFile : internal error !");
4187 throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::allocIfNecessaryTheArrayToReceiveDataFromFile : internal error !");
4190 void MEDFileAnyTypeField1TSWithoutSDA::loadOnlyStructureOfDataRecursively(med_idt fid, const MEDFileFieldNameScope& nasc)
4192 med_int numdt,numit;
4196 med_int meshnumdt,meshnumit;
4197 INTERP_KERNEL::AutoPtr<char> meshName=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
4198 MEDfieldComputingStepInfo(fid,nasc.getName().c_str(),_csit,&numdt,&numit,&_dt);
4199 MEDfield23ComputingStepMeshInfo(fid,nasc.getName().c_str(),_csit,&numdt,&numit,&dt,&nmesh,meshName,&localMesh,&meshnumdt,&meshnumit);
4200 if(_iteration!=numdt || _order!=numit)
4201 throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::loadBigArraysRecursively : unexpected exception internal error !");
4202 _field_per_mesh.resize(nmesh);
4203 for(int i=0;i<nmesh;i++)
4204 _field_per_mesh[i]=MEDFileFieldPerMesh::NewOnRead(fid,this,i+1,meshnumdt,meshnumit,nasc);//tony
4205 _nb_of_tuples_to_be_allocated=0;
4206 for(int i=0;i<nmesh;i++)
4207 _field_per_mesh[i]->loadOnlyStructureOfDataRecursively(fid,_nb_of_tuples_to_be_allocated,nasc);
4210 void MEDFileAnyTypeField1TSWithoutSDA::loadBigArraysRecursively(med_idt fid, const MEDFileFieldNameScope& nasc)
4212 allocIfNecessaryTheArrayToReceiveDataFromFile();
4213 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4214 (*it)->loadBigArraysRecursively(fid,nasc);
4217 void MEDFileAnyTypeField1TSWithoutSDA::loadBigArraysRecursivelyIfNecessary(med_idt fid, const MEDFileFieldNameScope& nasc)
4219 if(allocIfNecessaryTheArrayToReceiveDataFromFile())
4220 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4221 (*it)->loadBigArraysRecursively(fid,nasc);
4224 void MEDFileAnyTypeField1TSWithoutSDA::loadStructureAndBigArraysRecursively(med_idt fid, const MEDFileFieldNameScope& nasc)
4226 loadOnlyStructureOfDataRecursively(fid,nasc);
4227 loadBigArraysRecursively(fid,nasc);
4230 void MEDFileAnyTypeField1TSWithoutSDA::unloadArrays()
4232 DataArray *thisArr(getUndergroundDataArray());
4233 if(thisArr && thisArr->isAllocated())
4235 _nb_of_tuples_to_be_allocated=thisArr->getNumberOfTuples();
4236 thisArr->desallocate();
4240 std::size_t MEDFileAnyTypeField1TSWithoutSDA::getHeapMemorySizeWithoutChildren() const
4242 return _dt_unit.capacity()+_field_per_mesh.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh >);
4245 std::vector<const BigMemoryObject *> MEDFileAnyTypeField1TSWithoutSDA::getDirectChildren() const
4247 std::vector<const BigMemoryObject *> ret;
4248 if(getUndergroundDataArray())
4249 ret.push_back(getUndergroundDataArray());
4250 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileFieldPerMesh > >::const_iterator it=_field_per_mesh.begin();it!=_field_per_mesh.end();it++)
4252 const MEDFileFieldPerMesh *cur(*it);
4260 * Adds a MEDCouplingFieldDouble to \a this. The underlying mesh of the given field is
4261 * checked if its elements are sorted suitable for writing to MED file ("STB" stands for
4262 * "Sort By Type"), if not, an exception is thrown.
4263 * \param [in] field - the field to add to \a this. The array of field \a field is ignored
4264 * \param [in] arr - the array of values.
4265 * \param [in,out] glob - the global data where profiles and localization present in
4266 * \a field, if any, are added.
4267 * \throw If the name of \a field is empty.
4268 * \throw If the data array of \a field is not set.
4269 * \throw If \a this->_arr is already allocated but has different number of components
4271 * \throw If the underlying mesh of \a field has no name.
4272 * \throw If elements in the mesh are not in the order suitable for writing to the MED file.
4274 void MEDFileAnyTypeField1TSWithoutSDA::setFieldNoProfileSBT(const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc)
4276 const MEDCouplingMesh *mesh=field->getMesh();
4278 TypeOfField type=field->getTypeOfField();
4279 std::vector<DataArrayInt *> dummy;
4280 int start=copyTinyInfoFrom(field,arr);
4281 int pos=addNewEntryIfNecessary(mesh);
4284 std::vector<int> code=MEDFileField1TSWithoutSDA::CheckSBTMesh(mesh);
4285 _field_per_mesh[pos]->assignFieldNoProfileNoRenum(start,code,field,arr,glob,nasc);
4288 _field_per_mesh[pos]->assignNodeFieldNoProfile(start,field,arr,glob);
4292 * Adds a MEDCouplingFieldDouble to \a this. Specified entities of a given dimension
4293 * of a given mesh are used as the support of the given field (a real support is not used).
4294 * Elements of the given mesh must be sorted suitable for writing to MED file.
4295 * Order of underlying mesh entities of the given field specified by \a profile parameter
4296 * is not prescribed; this method permutes field values to have them sorted by element
4297 * type as required for writing to MED file. A new profile is added only if no equal
4298 * profile is missing.
4299 * \param [in] field - the field to add to \a this. The field double values are ignored.
4300 * \param [in] arrOfVals - the values of the field \a field used.
4301 * \param [in] mesh - the supporting mesh of \a field.
4302 * \param [in] meshDimRelToMax - a relative dimension of mesh entities \a field lies on.
4303 * \param [in] profile - ids of mesh entities on which corresponding field values lie.
4304 * \param [in,out] glob - the global data where profiles and localization present in
4305 * \a field, if any, are added.
4306 * \throw If either \a field or \a mesh or \a profile has an empty name.
4307 * \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
4308 * \throw If the data array of \a field is not set.
4309 * \throw If \a this->_arr is already allocated but has different number of components
4311 * \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
4312 * \sa setFieldNoProfileSBT()
4314 void MEDFileAnyTypeField1TSWithoutSDA::setFieldProfile(const MEDCouplingFieldDouble *field, const DataArray *arrOfVals, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile, MEDFileFieldGlobsReal& glob, const MEDFileFieldNameScope& nasc)
4317 throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::setFieldProfile : input field is null !");
4318 if(!arrOfVals || !arrOfVals->isAllocated())
4319 throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::setFieldProfile : input array is null or not allocated !");
4320 TypeOfField type=field->getTypeOfField();
4321 std::vector<DataArrayInt *> idsInPflPerType;
4322 std::vector<DataArrayInt *> idsPerType;
4323 std::vector<int> code,code2;
4324 MEDCouplingAutoRefCountObjectPtr<MEDCouplingMesh> m=mesh->getGenMeshAtLevel(meshDimRelToMax);
4327 m->splitProfilePerType(profile,code,idsInPflPerType,idsPerType);
4328 std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > idsInPflPerType2(idsInPflPerType.size()); std::copy(idsInPflPerType.begin(),idsInPflPerType.end(),idsInPflPerType2.begin());
4329 std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > idsPerType2(idsPerType.size()); std::copy(idsPerType.begin(),idsPerType.end(),idsPerType2.begin());
4330 std::vector<const DataArrayInt *> idsPerType3(idsPerType.size()); std::copy(idsPerType.begin(),idsPerType.end(),idsPerType3.begin());
4332 MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> field2=field->clone(false);
4333 int nbOfTuplesExp=field2->getNumberOfTuplesExpectedRegardingCode(code,idsPerType3);
4334 if(nbOfTuplesExp!=arrOfVals->getNumberOfTuples())
4336 std::ostringstream oss; oss << "MEDFileAnyTypeField1TSWithoutSDA::setFieldProfile : The array is expected to have " << nbOfTuplesExp << " tuples ! It has " << arrOfVals->getNumberOfTuples() << " !";
4337 throw INTERP_KERNEL::Exception(oss.str().c_str());
4340 int start=copyTinyInfoFrom(field,arrOfVals);
4341 code2=m->getDistributionOfTypes();
4343 int pos=addNewEntryIfNecessary(m);
4344 _field_per_mesh[pos]->assignFieldProfile(start,profile,code,code2,idsInPflPerType,idsPerType,field,arrOfVals,m,glob,nasc);
4348 if(!profile || !profile->isAllocated() || profile->getNumberOfComponents()!=1)
4349 throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::setFieldProfile : input profile is null, not allocated or with number of components != 1 !");
4350 std::vector<int> v(3); v[0]=-1; v[1]=profile->getNumberOfTuples(); v[2]=0;
4351 std::vector<const DataArrayInt *> idsPerType3(1); idsPerType3[0]=profile;
4352 int nbOfTuplesExp=field->getNumberOfTuplesExpectedRegardingCode(v,idsPerType3);
4353 if(nbOfTuplesExp!=arrOfVals->getNumberOfTuples())
4355 std::ostringstream oss; oss << "MEDFileAnyTypeField1TSWithoutSDA::setFieldProfile : For node field, the array is expected to have " << nbOfTuplesExp << " tuples ! It has " << arrOfVals->getNumberOfTuples() << " !";
4356 throw INTERP_KERNEL::Exception(oss.str().c_str());
4358 int start=copyTinyInfoFrom(field,arrOfVals);
4359 int pos=addNewEntryIfNecessary(m);
4360 _field_per_mesh[pos]->assignNodeFieldProfile(start,profile,field,arrOfVals,glob,nasc);
4365 * \param [in] newNbOfTuples - The new nb of tuples to be allocated.
4367 void MEDFileAnyTypeField1TSWithoutSDA::allocNotFromFile(int newNbOfTuples)
4369 if(_nb_of_tuples_to_be_allocated>=0)
4370 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 !");
4371 DataArray *arr(getOrCreateAndGetArray());
4372 arr->alloc(newNbOfTuples,arr->getNumberOfComponents());
4373 _nb_of_tuples_to_be_allocated=-3;
4377 * Copies tiny info and allocates \a this->_arr instance of DataArrayDouble to
4378 * append data of a given MEDCouplingFieldDouble. So that the size of \a this->_arr becomes
4379 * larger by the size of \a field. Returns an id of the first not filled
4380 * tuple of \a this->_arr.
4381 * \param [in] field - the field to copy the info on components and the name from.
4382 * \return int - the id of first not initialized tuple of \a this->_arr.
4383 * \throw If the name of \a field is empty.
4384 * \throw If the data array of \a field is not set.
4385 * \throw If \a this->_arr is already allocated but has different number of components
4388 int MEDFileAnyTypeField1TSWithoutSDA::copyTinyInfoFrom(const MEDCouplingFieldDouble *field, const DataArray *arr)
4391 throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::copyTinyInfoFrom : input field is NULL !");
4392 std::string name(field->getName());
4393 setName(name.c_str());
4394 setDtUnit(field->getTimeUnit());
4396 throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::copyTinyInfoFrom : unsupported fields with no name in MED file !");
4398 throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::copyTinyInfoFrom : no array set !");
4399 if(!arr->isAllocated())
4400 throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::copyTinyInfoFrom : array is not allocated !");
4401 _dt=field->getTime(_iteration,_order);
4402 getOrCreateAndGetArray()->setInfoAndChangeNbOfCompo(arr->getInfoOnComponents());
4403 if(!getOrCreateAndGetArray()->isAllocated())
4405 allocNotFromFile(arr->getNumberOfTuples());
4410 int oldNbOfTuples=getOrCreateAndGetArray()->getNumberOfTuples();
4411 int newNbOfTuples=oldNbOfTuples+arr->getNumberOfTuples();
4412 getOrCreateAndGetArray()->reAlloc(newNbOfTuples);
4413 _nb_of_tuples_to_be_allocated=-3;
4414 return oldNbOfTuples;
4419 * Returns number of components in \a this field
4420 * \return int - the number of components.
4422 int MEDFileAnyTypeField1TSWithoutSDA::getNumberOfComponents() const
4424 return getOrCreateAndGetArray()->getNumberOfComponents();
4428 * Change info on components in \a this.
4429 * \throw If size of \a infos is not equal to the number of components already in \a this.
4431 void MEDFileAnyTypeField1TSWithoutSDA::setInfo(const std::vector<std::string>& infos)
4433 DataArray *arr=getOrCreateAndGetArray();
4434 arr->setInfoOnComponents(infos);//will throw an exception if number of components mimatches
4438 * Returns info on components of \a this field.
4439 * \return const std::vector<std::string>& - a sequence of strings each being an
4440 * information on _i_-th component.
4442 const std::vector<std::string>& MEDFileAnyTypeField1TSWithoutSDA::getInfo() const
4444 const DataArray *arr=getOrCreateAndGetArray();
4445 return arr->getInfoOnComponents();
4449 * Returns a mutable info on components of \a this field.
4450 * \return std::vector<std::string>& - a sequence of strings each being an
4451 * information on _i_-th component.
4453 std::vector<std::string>& MEDFileAnyTypeField1TSWithoutSDA::getInfo()
4455 DataArray *arr=getOrCreateAndGetArray();
4456 return arr->getInfoOnComponents();
4460 * Returns a new MEDCouplingFieldDouble of given type lying on a given support.
4461 * \param [in] type - a spatial discretization of the new field.
4462 * \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
4463 * \param [in] mName - a name of the supporting mesh.
4464 * \param [in] renumPol - specifies how to permute values of the result field according to
4465 * the optional numbers of cells and nodes, if any. The valid values are
4466 * - 0 - do not permute.
4467 * - 1 - permute cells.
4468 * - 2 - permute nodes.
4469 * - 3 - permute cells and nodes.
4471 * \param [in] glob - the global data storing profiles and localization.
4472 * \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
4473 * caller is to delete this field using decrRef() as it is no more needed.
4474 * \throw If the MED file is not readable.
4475 * \throw If there is no mesh named \a mName in the MED file.
4476 * \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
4477 * \throw If no field of \a this is lying on the mesh \a mName.
4478 * \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
4480 MEDCouplingFieldDouble *MEDFileAnyTypeField1TSWithoutSDA::getFieldAtLevel(TypeOfField type, int meshDimRelToMax, const std::string& mName, int renumPol, const MEDFileFieldGlobsReal *glob, MEDCouplingAutoRefCountObjectPtr<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const
4482 MEDCouplingAutoRefCountObjectPtr<MEDFileMesh> mm;
4484 mm=MEDFileMesh::New(glob->getFileName(),getMeshName().c_str(),getMeshIteration(),getMeshOrder());
4486 mm=MEDFileMesh::New(glob->getFileName(),mName,getMeshIteration(),getMeshOrder());
4487 return MEDFileAnyTypeField1TSWithoutSDA::getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,glob,mm,arrOut,nasc);
4491 * Returns a new MEDCouplingFieldDouble of given type lying on a given support.
4492 * \param [in] type - a spatial discretization of the new field.
4493 * \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
4494 * \param [in] renumPol - specifies how to permute values of the result field according to
4495 * the optional numbers of cells and nodes, if any. The valid values are
4496 * - 0 - do not permute.
4497 * - 1 - permute cells.
4498 * - 2 - permute nodes.
4499 * - 3 - permute cells and nodes.
4501 * \param [in] glob - the global data storing profiles and localization.
4502 * \param [in] mesh - the supporting mesh.
4503 * \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
4504 * caller is to delete this field using decrRef() as it is no more needed.
4505 * \throw If the MED file is not readable.
4506 * \throw If no field of \a this is lying on \a mesh.
4507 * \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
4508 * \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
4510 MEDCouplingFieldDouble *MEDFileAnyTypeField1TSWithoutSDA::getFieldOnMeshAtLevel(TypeOfField type, int meshDimRelToMax, int renumPol, const MEDFileFieldGlobsReal *glob, const MEDFileMesh *mesh, MEDCouplingAutoRefCountObjectPtr<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const
4512 MEDCouplingAutoRefCountObjectPtr<MEDCouplingMesh> m=mesh->getGenMeshAtLevel(meshDimRelToMax,false);
4513 const DataArrayInt *d=mesh->getNumberFieldAtLevel(meshDimRelToMax);
4514 const DataArrayInt *e=mesh->getNumberFieldAtLevel(1);
4515 if(meshDimRelToMax==1)
4516 (static_cast<MEDCouplingUMesh *>((MEDCouplingMesh *)m))->setMeshDimension(0);
4517 return MEDFileAnyTypeField1TSWithoutSDA::getFieldOnMeshAtLevel(type,renumPol,glob,m,d,e,arrOut,nasc);
4521 * Returns a new MEDCouplingFieldDouble of a given type lying on the top level cells of a
4523 * \param [in] type - a spatial discretization of the new field.
4524 * \param [in] mName - a name of the supporting mesh.
4525 * \param [in] renumPol - specifies how to permute values of the result field according to
4526 * the optional numbers of cells and nodes, if any. The valid values are
4527 * - 0 - do not permute.
4528 * - 1 - permute cells.
4529 * - 2 - permute nodes.
4530 * - 3 - permute cells and nodes.
4532 * \param [in] glob - the global data storing profiles and localization.
4533 * \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
4534 * caller is to delete this field using decrRef() as it is no more needed.
4535 * \throw If the MED file is not readable.
4536 * \throw If there is no mesh named \a mName in the MED file.
4537 * \throw If there are no mesh entities in the mesh.
4538 * \throw If no field values of the given \a type are available.
4540 MEDCouplingFieldDouble *MEDFileAnyTypeField1TSWithoutSDA::getFieldAtTopLevel(TypeOfField type, const std::string& mName, int renumPol, const MEDFileFieldGlobsReal *glob, MEDCouplingAutoRefCountObjectPtr<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const
4542 MEDCouplingAutoRefCountObjectPtr<MEDFileMesh> mm;
4544 mm=MEDFileMesh::New(glob->getFileName(),getMeshName().c_str(),getMeshIteration(),getMeshOrder());
4546 mm=MEDFileMesh::New(glob->getFileName(),mName,getMeshIteration(),getMeshOrder());
4547 int absDim=getDimension();
4548 int meshDimRelToMax=absDim-mm->getMeshDimension();
4549 return MEDFileAnyTypeField1TSWithoutSDA::getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,glob,mm,arrOut,nasc);
4553 * Returns a new MEDCouplingFieldDouble of given type lying on a given support.
4554 * \param [in] type - a spatial discretization of the new field.
4555 * \param [in] renumPol - specifies how to permute values of the result field according to
4556 * the optional numbers of cells and nodes, if any. The valid values are
4557 * - 0 - do not permute.
4558 * - 1 - permute cells.
4559 * - 2 - permute nodes.
4560 * - 3 - permute cells and nodes.
4562 * \param [in] glob - the global data storing profiles and localization.
4563 * \param [in] mesh - the supporting mesh.
4564 * \param [in] cellRenum - the cell numbers array used for permutation of the result
4565 * field according to \a renumPol.
4566 * \param [in] nodeRenum - the node numbers array used for permutation of the result
4567 * field according to \a renumPol.
4568 * \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
4569 * caller is to delete this field using decrRef() as it is no more needed.
4570 * \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
4571 * \throw If no field of \a this is lying on \a mesh.
4572 * \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
4574 MEDCouplingFieldDouble *MEDFileAnyTypeField1TSWithoutSDA::getFieldOnMeshAtLevel(TypeOfField type, int renumPol, const MEDFileFieldGlobsReal *glob, const MEDCouplingMesh *mesh, const DataArrayInt *cellRenum, const DataArrayInt *nodeRenum, MEDCouplingAutoRefCountObjectPtr<DataArray>& arrOut, const MEDFileFieldNameScope& nasc) const
4576 static const char msg1[]="MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel : request for a renumbered field following mesh numbering whereas it is a profile field !";
4577 int meshId=getMeshIdFromMeshName(mesh->getName());
4579 MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=_field_per_mesh[meshId]->getFieldOnMeshAtLevel(type,glob,mesh,isPfl,arrOut,nasc);
4584 //no need to test _field_per_mesh.empty() because geMeshName has already done it
4591 throw INTERP_KERNEL::Exception(msg1);
4592 //no need to test _field_per_mesh.empty() because geMeshName has already done it
4595 if((int)cellRenum->getNbOfElems()!=mesh->getNumberOfCells())
4597 std::ostringstream oss; oss << "MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel : Request of simple renumbering but it seems that underlying mesh \"" << mesh->getName() << "\" of requested field ";
4598 oss << "\"" << getName() << "\" has partial renumbering (some geotype has no renumber) !";
4599 throw INTERP_KERNEL::Exception(oss.str().c_str());
4601 MEDCouplingFieldDiscretization *disc=ret->getDiscretization();
4602 if(!disc) throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TSWithoutSDA::getFieldOnMeshAtLevel : internal error, no discretization on field !");
4603 std::vector<DataArray *> arrOut2(1,arrOut);
4604 // 2 following lines replace ret->renumberCells(cellRenum->getConstPointer()) if not DataArrayDouble
4605 disc->renumberArraysForCell(ret->getMesh(),arrOut2,cellRenum->getConstPointer(),true);
4606 (const_cast<MEDCouplingMesh*>(ret->getMesh()))->renumberCells(cellRenum->getConstPointer(),true);
4613 //no need to test _field_per_mesh.empty() because geMeshName has already done it
4615 throw INTERP_KERNEL::Exception(msg1);
4618 if((int)nodeRenum->getNbOfElems()!=mesh->getNumberOfNodes())
4620 std::ostringstream oss; oss << "MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel : Request of simple renumbering but it seems that underlying mesh \"" << mesh->getName() << "\" of requested field ";
4621 oss << "\"" << nasc.getName() << "\" not defined on all nodes !";
4622 throw INTERP_KERNEL::Exception(oss.str().c_str());
4624 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> nodeRenumSafe=nodeRenum->checkAndPreparePermutation();
4625 if(!dynamic_cast<DataArrayDouble *>((DataArray *)arrOut))
4626 throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel : node renumbering not implemented for not double DataArrays !");
4627 ret->renumberNodes(nodeRenumSafe->getConstPointer());
4632 throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getFieldOnMeshAtLevel : unsupported renum policy ! Dealing with policy 0 1 2 and 3 !");
4637 * Returns values and a profile of the field of a given type lying on a given support.
4638 * \param [in] type - a spatial discretization of the field.
4639 * \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
4640 * \param [in] mesh - the supporting mesh.
4641 * \param [out] pfl - a new instance of DataArrayInt holding ids of mesh entities the
4642 * field of interest lies on. If the field lies on all entities of the given
4643 * dimension, all ids in \a pfl are zero. The caller is to delete this array
4644 * using decrRef() as it is no more needed.
4645 * \param [in] glob - the global data storing profiles and localization.
4646 * \return DataArrayDouble * - a new instance of DataArrayDouble holding values of the
4647 * field. The caller is to delete this array using decrRef() as it is no more needed.
4648 * \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
4649 * \throw If no field of \a this is lying on \a mesh.
4650 * \throw If no field values of the given \a type are available.
4652 DataArray *MEDFileAnyTypeField1TSWithoutSDA::getFieldWithProfile(TypeOfField type, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt *&pfl, const MEDFileFieldGlobsReal *glob, const MEDFileFieldNameScope& nasc) const
4654 MEDCouplingAutoRefCountObjectPtr<MEDCouplingMesh> m=mesh->getGenMeshAtLevel(meshDimRelToMax);
4655 int meshId=getMeshIdFromMeshName(mesh->getName().c_str());
4656 MEDCouplingAutoRefCountObjectPtr<DataArray> ret=_field_per_mesh[meshId]->getFieldOnMeshAtLevelWithPfl(type,m,pfl,glob,nasc);
4657 ret->setName(nasc.getName().c_str());
4661 //= MEDFileField1TSWithoutSDA
4664 * Throws if a given value is not a valid (non-extended) relative dimension.
4665 * \param [in] meshDimRelToMax - the relative dimension value.
4666 * \throw If \a meshDimRelToMax > 0.
4668 void MEDFileField1TSWithoutSDA::CheckMeshDimRel(int meshDimRelToMax)
4670 if(meshDimRelToMax>0)
4671 throw INTERP_KERNEL::Exception("CheckMeshDimRel : This is a meshDimRel not a meshDimRelExt ! So value should be <=0 !");
4675 * Checks if elements of a given mesh are in the order suitable for writing
4676 * to the MED file. If this is not so, an exception is thrown. In a case of success, returns a
4677 * vector describing types of elements and their number.
4678 * \param [in] mesh - the mesh to check.
4679 * \return std::vector<int> - a vector holding for each element type (1) item of
4680 * INTERP_KERNEL::NormalizedCellType, (2) number of elements, (3) -1.
4681 * These values are in full-interlace mode.
4682 * \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
4684 std::vector<int> MEDFileField1TSWithoutSDA::CheckSBTMesh(const MEDCouplingMesh *mesh)
4687 throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::CheckSBTMesh : input mesh is NULL !");
4688 std::set<INTERP_KERNEL::NormalizedCellType> geoTypes=mesh->getAllGeoTypes();
4689 int nbOfTypes=geoTypes.size();
4690 std::vector<int> code(3*nbOfTypes);
4691 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr1=DataArrayInt::New();
4692 arr1->alloc(nbOfTypes,1);
4693 int *arrPtr=arr1->getPointer();
4694 std::set<INTERP_KERNEL::NormalizedCellType>::const_iterator it=geoTypes.begin();
4695 for(int i=0;i<nbOfTypes;i++,it++)
4696 arrPtr[i]=std::distance(typmai2,std::find(typmai2,typmai2+MED_N_CELL_FIXED_GEO,*it));
4697 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr2=arr1->checkAndPreparePermutation();
4698 const int *arrPtr2=arr2->getConstPointer();
4700 for(it=geoTypes.begin();it!=geoTypes.end();it++,i++)
4703 int nbCells=mesh->getNumberOfCellsWithType(*it);
4704 code[3*pos]=(int)(*it);
4705 code[3*pos+1]=nbCells;
4706 code[3*pos+2]=-1;//no profiles
4708 std::vector<const DataArrayInt *> idsPerType;//no profiles
4709 DataArrayInt *da=mesh->checkTypeConsistencyAndContig(code,idsPerType);
4713 throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::CheckSBTMesh : underlying mesh is not sorted by type as MED file expects !");
4718 MEDFileField1TSWithoutSDA *MEDFileField1TSWithoutSDA::New(const std::string& fieldName, int csit, int iteration, int order, const std::vector<std::string>& infos)
4720 return new MEDFileField1TSWithoutSDA(fieldName,csit,iteration,order,infos);
4724 * Returns all attributes and values of parts of \a this field lying on a given mesh.
4725 * Each part differs from other ones by a type of supporting mesh entity. The _i_-th
4726 * item of every of returned sequences refers to the _i_-th part of \a this field.
4727 * Thus all sequences returned by this method are of the same length equal to number
4728 * of different types of supporting entities.<br>
4729 * A field part can include sub-parts with several different spatial discretizations,
4730 * \ref ParaMEDMEM::ON_CELLS "ON_CELLS" and \ref ParaMEDMEM::ON_GAUSS_PT "ON_GAUSS_PT"
4731 * for example. Hence, some of the returned sequences contains nested sequences, and an item
4732 * of a nested sequence corresponds to a type of spatial discretization.<br>
4733 * This method allows for iteration over MEDFile DataStructure with a reduced overhead.
4734 * The overhead is due to selecting values into new instances of DataArrayDouble.
4735 * \param [in] mname - a name of a mesh of interest. It can be \c NULL, which is valid
4736 * for the case with only one underlying mesh. (Actually, the number of meshes is
4737 * not checked if \a mname == \c NULL).
4738 * \param [in,out] types - a sequence of types of underlying mesh entities. A type per
4739 * a field part is returned.
4740 * \param [in,out] typesF - a sequence of sequences of types of spatial discretizations.
4741 * A field part can include sub-parts with several different spatial discretizations,
4742 * \ref ParaMEDMEM::ON_CELLS "ON_CELLS" and
4743 * \ref ParaMEDMEM::ON_GAUSS_PT "ON_GAUSS_PT" for example.
4744 * This sequence is of the same length as \a types.
4745 * \param [in,out] pfls - a sequence returning a profile name per each type of spatial
4746 * discretization. A profile name can be empty.
4747 * Length of this and of nested sequences is the same as that of \a typesF.
4748 * \param [in,out] locs - a sequence returning a localization name per each type of spatial
4749 * discretization. A localization name can be empty.
4750 * Length of this and of nested sequences is the same as that of \a typesF.
4751 * \return std::vector< std::vector<DataArrayDouble *> > - a sequence holding arrays of values
4752 * per each type of spatial discretization within one mesh entity type.
4753 * The caller is to delete each DataArrayDouble using decrRef() as it is no more needed.
4754 * Length of this and of nested sequences is the same as that of \a typesF.
4755 * \throw If no field is lying on \a mname.
4757 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
4761 meshId=getMeshIdFromMeshName(mname);
4763 if(_field_per_mesh.empty())
4764 throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getFieldSplitedByType : This is empty !");
4765 std::vector< std::vector< std::pair<int,int> > > ret0=_field_per_mesh[meshId]->getFieldSplitedByType(types,typesF,pfls,locs);
4766 int nbOfRet=ret0.size();
4767 std::vector< std::vector<DataArrayDouble *> > ret(nbOfRet);
4768 for(int i=0;i<nbOfRet;i++)
4770 const std::vector< std::pair<int,int> >& p=ret0[i];
4771 int nbOfRet1=p.size();
4772 ret[i].resize(nbOfRet1);
4773 for(int j=0;j<nbOfRet1;j++)
4775 DataArrayDouble *tmp=_arr->selectByTupleId2(p[j].first,p[j].second,1);
4783 * Returns a pointer to the underground DataArrayDouble instance. So the
4784 * caller should not decrRef() it. This method allows for a direct access to the field
4785 * values. This method is quite unusable if there is more than a nodal field or a cell
4786 * field on single geometric cell type.
4787 * \return DataArrayDouble * - the pointer to the field values array.
4789 DataArrayDouble *MEDFileField1TSWithoutSDA::getUndergroundDataArrayDouble() const
4791 const DataArrayDouble *ret=_arr;
4793 return const_cast<DataArrayDouble *>(ret);
4798 const char *MEDFileField1TSWithoutSDA::getTypeStr() const
4803 MEDFileIntField1TSWithoutSDA *MEDFileField1TSWithoutSDA::convertToInt() const
4805 MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TSWithoutSDA> ret(new MEDFileIntField1TSWithoutSDA);
4806 ret->MEDFileAnyTypeField1TSWithoutSDA::operator =(*this);
4807 ret->deepCpyLeavesFrom(*this);
4808 const DataArrayDouble *arr(_arr);
4811 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr2(arr->convertToIntArr());
4812 ret->setArray(arr2);
4818 * Returns a pointer to the underground DataArrayDouble instance. So the
4819 * caller should not decrRef() it. This method allows for a direct access to the field
4820 * values. This method is quite unusable if there is more than a nodal field or a cell
4821 * field on single geometric cell type.
4822 * \return DataArrayDouble * - the pointer to the field values array.
4824 DataArray *MEDFileField1TSWithoutSDA::getUndergroundDataArray() const
4826 return getUndergroundDataArrayDouble();
4830 * Returns a pointer to the underground DataArrayDouble instance and a
4831 * sequence describing parameters of a support of each part of \a this field. The
4832 * caller should not decrRef() the returned DataArrayDouble. This method allows for a
4833 * direct access to the field values. This method is intended for the field lying on one
4835 * \param [in,out] entries - the sequence describing parameters of a support of each
4836 * part of \a this field. Each item of this sequence consists of two parts. The
4837 * first part describes a type of mesh entity and an id of discretization of a
4838 * current field part. The second part describes a range of values [begin,end)
4839 * within the returned array relating to the current field part.
4840 * \return DataArrayDouble * - the pointer to the field values array.
4841 * \throw If the number of underlying meshes is not equal to 1.
4842 * \throw If no field values are available.
4843 * \sa getUndergroundDataArray()
4845 DataArrayDouble *MEDFileField1TSWithoutSDA::getUndergroundDataArrayDoubleExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
4847 if(_field_per_mesh.size()!=1)
4848 throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt : field lies on several meshes, this method has no sense !");
4849 if(_field_per_mesh[0]==0)
4850 throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt : no field specified !");
4851 _field_per_mesh[0]->getUndergroundDataArrayExt(entries);
4852 return getUndergroundDataArrayDouble();
4856 * Returns a pointer to the underground DataArrayDouble instance and a
4857 * sequence describing parameters of a support of each part of \a this field. The
4858 * caller should not decrRef() the returned DataArrayDouble. This method allows for a
4859 * direct access to the field values. This method is intended for the field lying on one
4861 * \param [in,out] entries - the sequence describing parameters of a support of each
4862 * part of \a this field. Each item of this sequence consists of two parts. The
4863 * first part describes a type of mesh entity and an id of discretization of a
4864 * current field part. The second part describes a range of values [begin,end)
4865 * within the returned array relating to the current field part.
4866 * \return DataArrayDouble * - the pointer to the field values array.
4867 * \throw If the number of underlying meshes is not equal to 1.
4868 * \throw If no field values are available.
4869 * \sa getUndergroundDataArray()
4871 DataArray *MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
4873 return getUndergroundDataArrayDoubleExt(entries);
4876 MEDFileField1TSWithoutSDA::MEDFileField1TSWithoutSDA(const std::string& fieldName, int csit, int iteration, int order,
4877 const std::vector<std::string>& infos):MEDFileAnyTypeField1TSWithoutSDA(fieldName,csit,iteration,order)
4879 DataArrayDouble *arr=getOrCreateAndGetArrayDouble();
4880 arr->setInfoAndChangeNbOfCompo(infos);
4883 MEDFileField1TSWithoutSDA::MEDFileField1TSWithoutSDA():MEDFileAnyTypeField1TSWithoutSDA()
4887 MEDFileAnyTypeField1TSWithoutSDA *MEDFileField1TSWithoutSDA::shallowCpy() const
4889 MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA> ret(new MEDFileField1TSWithoutSDA(*this));
4890 ret->deepCpyLeavesFrom(*this);
4894 MEDFileAnyTypeField1TSWithoutSDA *MEDFileField1TSWithoutSDA::deepCpy() const
4896 MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA> ret=static_cast<MEDFileField1TSWithoutSDA *>(shallowCpy());
4897 if((const DataArrayDouble *)_arr)
4898 ret->_arr=_arr->deepCpy();
4902 void MEDFileField1TSWithoutSDA::setArray(DataArray *arr)
4906 _nb_of_tuples_to_be_allocated=-1;
4910 DataArrayDouble *arrC=dynamic_cast<DataArrayDouble *>(arr);
4912 throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::setArray : the input not null array is not of type DataArrayDouble !");
4914 _nb_of_tuples_to_be_allocated=-3;
4919 DataArray *MEDFileField1TSWithoutSDA::createNewEmptyDataArrayInstance() const
4921 return DataArrayDouble::New();
4924 DataArrayDouble *MEDFileField1TSWithoutSDA::getOrCreateAndGetArrayDouble()
4926 DataArrayDouble *ret=_arr;
4929 _arr=DataArrayDouble::New();
4933 DataArray *MEDFileField1TSWithoutSDA::getOrCreateAndGetArray()
4935 return getOrCreateAndGetArrayDouble();
4938 const DataArrayDouble *MEDFileField1TSWithoutSDA::getOrCreateAndGetArrayDouble() const
4940 const DataArrayDouble *ret=_arr;
4943 DataArrayDouble *ret2=DataArrayDouble::New();
4944 const_cast<MEDFileField1TSWithoutSDA *>(this)->_arr=DataArrayDouble::New();
4948 const DataArray *MEDFileField1TSWithoutSDA::getOrCreateAndGetArray() const
4950 return getOrCreateAndGetArrayDouble();
4953 //= MEDFileIntField1TSWithoutSDA
4955 MEDFileIntField1TSWithoutSDA *MEDFileIntField1TSWithoutSDA::New(const std::string& fieldName, int csit, int iteration, int order,
4956 const std::vector<std::string>& infos)
4958 return new MEDFileIntField1TSWithoutSDA(fieldName,csit,iteration,order,infos);
4961 MEDFileIntField1TSWithoutSDA::MEDFileIntField1TSWithoutSDA():MEDFileAnyTypeField1TSWithoutSDA()
4965 MEDFileIntField1TSWithoutSDA::MEDFileIntField1TSWithoutSDA(const std::string& fieldName, int csit, int iteration, int order,
4966 const std::vector<std::string>& infos):MEDFileAnyTypeField1TSWithoutSDA(fieldName,csit,iteration,order)
4968 DataArrayInt *arr=getOrCreateAndGetArrayInt();
4969 arr->setInfoAndChangeNbOfCompo(infos);
4972 const char *MEDFileIntField1TSWithoutSDA::getTypeStr() const
4977 MEDFileField1TSWithoutSDA *MEDFileIntField1TSWithoutSDA::convertToDouble() const
4979 MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA> ret(new MEDFileField1TSWithoutSDA);
4980 ret->MEDFileAnyTypeField1TSWithoutSDA::operator =(*this);
4981 ret->deepCpyLeavesFrom(*this);
4982 const DataArrayInt *arr(_arr);
4985 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> arr2(arr->convertToDblArr());
4986 ret->setArray(arr2);
4992 * Returns a pointer to the underground DataArrayInt instance. So the
4993 * caller should not decrRef() it. This method allows for a direct access to the field
4994 * values. This method is quite unusable if there is more than a nodal field or a cell
4995 * field on single geometric cell type.
4996 * \return DataArrayInt * - the pointer to the field values array.
4998 DataArray *MEDFileIntField1TSWithoutSDA::getUndergroundDataArray() const
5000 return getUndergroundDataArrayInt();
5004 * Returns a pointer to the underground DataArrayInt instance. So the
5005 * caller should not decrRef() it. This method allows for a direct access to the field
5006 * values. This method is quite unusable if there is more than a nodal field or a cell
5007 * field on single geometric cell type.
5008 * \return DataArrayInt * - the pointer to the field values array.
5010 DataArrayInt *MEDFileIntField1TSWithoutSDA::getUndergroundDataArrayInt() const
5012 const DataArrayInt *ret=_arr;
5014 return const_cast<DataArrayInt *>(ret);
5020 * Returns a pointer to the underground DataArrayInt instance and a
5021 * sequence describing parameters of a support of each part of \a this field. The
5022 * caller should not decrRef() the returned DataArrayInt. This method allows for a
5023 * direct access to the field values. This method is intended for the field lying on one
5025 * \param [in,out] entries - the sequence describing parameters of a support of each
5026 * part of \a this field. Each item of this sequence consists of two parts. The
5027 * first part describes a type of mesh entity and an id of discretization of a
5028 * current field part. The second part describes a range of values [begin,end)
5029 * within the returned array relating to the current field part.
5030 * \return DataArrayInt * - the pointer to the field values array.
5031 * \throw If the number of underlying meshes is not equal to 1.
5032 * \throw If no field values are available.
5033 * \sa getUndergroundDataArray()
5035 DataArray *MEDFileIntField1TSWithoutSDA::getUndergroundDataArrayExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
5037 return getUndergroundDataArrayIntExt(entries);
5041 * Returns a pointer to the underground DataArrayInt instance and a
5042 * sequence describing parameters of a support of each part of \a this field. The
5043 * caller should not decrRef() the returned DataArrayInt. This method allows for a
5044 * direct access to the field values. This method is intended for the field lying on one
5046 * \param [in,out] entries - the sequence describing parameters of a support of each
5047 * part of \a this field. Each item of this sequence consists of two parts. The
5048 * first part describes a type of mesh entity and an id of discretization of a
5049 * current field part. The second part describes a range of values [begin,end)
5050 * within the returned array relating to the current field part.
5051 * \return DataArrayInt * - the pointer to the field values array.
5052 * \throw If the number of underlying meshes is not equal to 1.
5053 * \throw If no field values are available.
5054 * \sa getUndergroundDataArray()
5056 DataArrayInt *MEDFileIntField1TSWithoutSDA::getUndergroundDataArrayIntExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
5058 if(_field_per_mesh.size()!=1)
5059 throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt : field lies on several meshes, this method has no sense !");
5060 if(_field_per_mesh[0]==0)
5061 throw INTERP_KERNEL::Exception("MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt : no field specified !");
5062 _field_per_mesh[0]->getUndergroundDataArrayExt(entries);
5063 return getUndergroundDataArrayInt();
5066 MEDFileAnyTypeField1TSWithoutSDA *MEDFileIntField1TSWithoutSDA::shallowCpy() const
5068 MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TSWithoutSDA> ret(new MEDFileIntField1TSWithoutSDA(*this));
5069 ret->deepCpyLeavesFrom(*this);
5073 MEDFileAnyTypeField1TSWithoutSDA *MEDFileIntField1TSWithoutSDA::deepCpy() const
5075 MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TSWithoutSDA> ret=static_cast<MEDFileIntField1TSWithoutSDA *>(shallowCpy());
5076 if((const DataArrayInt *)_arr)
5077 ret->_arr=_arr->deepCpy();
5081 void MEDFileIntField1TSWithoutSDA::setArray(DataArray *arr)
5085 _nb_of_tuples_to_be_allocated=-1;
5089 DataArrayInt *arrC=dynamic_cast<DataArrayInt *>(arr);
5091 throw INTERP_KERNEL::Exception("MEDFileIntField1TSWithoutSDA::setArray : the input not null array is not of type DataArrayInt !");
5093 _nb_of_tuples_to_be_allocated=-3;
5098 DataArray *MEDFileIntField1TSWithoutSDA::createNewEmptyDataArrayInstance() const
5100 return DataArrayInt::New();
5103 DataArrayInt *MEDFileIntField1TSWithoutSDA::getOrCreateAndGetArrayInt()
5105 DataArrayInt *ret=_arr;
5108 _arr=DataArrayInt::New();
5112 DataArray *MEDFileIntField1TSWithoutSDA::getOrCreateAndGetArray()
5114 return getOrCreateAndGetArrayInt();
5117 const DataArrayInt *MEDFileIntField1TSWithoutSDA::getOrCreateAndGetArrayInt() const
5119 const DataArrayInt *ret=_arr;
5122 DataArrayInt *ret2=DataArrayInt::New();
5123 const_cast<MEDFileIntField1TSWithoutSDA *>(this)->_arr=DataArrayInt::New();
5127 const DataArray *MEDFileIntField1TSWithoutSDA::getOrCreateAndGetArray() const
5129 return getOrCreateAndGetArrayInt();
5132 MEDFileAnyTypeField1TS::MEDFileAnyTypeField1TS()
5136 //= MEDFileAnyTypeField1TS
5138 MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeField1TS::BuildContentFrom(med_idt fid, const std::string& fileName, bool loadAll)
5140 med_field_type typcha;
5142 std::vector<std::string> infos;
5143 std::string dtunit,fieldName;
5144 LocateField2(fid,fileName,0,true,fieldName,typcha,infos,dtunit);
5145 MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> ret;
5150 ret=MEDFileField1TSWithoutSDA::New(fieldName.c_str(),-1,-1/*iteration*/,-1/*order*/,std::vector<std::string>());
5155 ret=MEDFileIntField1TSWithoutSDA::New(fieldName.c_str(),-1,-1/*iteration*/,-1/*order*/,std::vector<std::string>());
5160 std::ostringstream oss; oss << "MEDFileAnyTypeField1TS::BuildContentFrom(fileName) : file \'" << fileName << "\' contains field with name \'" << fieldName << "\' but the type of the first field is not in [MED_FLOAT64, MED_INT32] !";
5161 throw INTERP_KERNEL::Exception(oss.str().c_str());
5164 ret->setDtUnit(dtunit.c_str());
5165 ret->getOrCreateAndGetArray()->setInfoAndChangeNbOfCompo(infos);
5167 med_int numdt,numit;
5169 MEDfieldComputingStepInfo(fid,fieldName.c_str(),1,&numdt,&numit,&dt);
5170 ret->setTime(numdt,numit,dt);
5173 ret->loadStructureAndBigArraysRecursively(fid,*((const MEDFileAnyTypeField1TSWithoutSDA*)ret));
5175 ret->loadOnlyStructureOfDataRecursively(fid,*((const MEDFileAnyTypeField1TSWithoutSDA*)ret));
5179 MEDFileAnyTypeField1TS::MEDFileAnyTypeField1TS(const std::string& fileName, bool loadAll)
5180 try:MEDFileFieldGlobsReal(fileName)
5182 MEDFileUtilities::CheckFileForRead(fileName);
5183 MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
5184 _content=BuildContentFrom(fid,fileName,loadAll);
5187 catch(INTERP_KERNEL::Exception& e)
5192 MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeField1TS::BuildContentFrom(med_idt fid, const std::string& fileName, const std::string& fieldName, bool loadAll)
5194 med_field_type typcha;
5195 std::vector<std::string> infos;
5198 int nbSteps=LocateField(fid,fileName,fieldName,iii,typcha,infos,dtunit);
5199 MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> ret;
5204 ret=MEDFileField1TSWithoutSDA::New(fieldName,-1,-1/*iteration*/,-1/*order*/,std::vector<std::string>());
5209 ret=MEDFileIntField1TSWithoutSDA::New(fieldName,-1,-1/*iteration*/,-1/*order*/,std::vector<std::string>());
5214 std::ostringstream oss; oss << "MEDFileAnyTypeField1TS::BuildContentFrom(fileName,fieldName) : file \'" << fileName << "\' contains field with name \'" << fieldName << "\' but the type of field is not in [MED_FLOAT64, MED_INT32] !";
5215 throw INTERP_KERNEL::Exception(oss.str().c_str());
5218 ret->setDtUnit(dtunit.c_str());
5219 ret->getOrCreateAndGetArray()->setInfoAndChangeNbOfCompo(infos);
5223 std::ostringstream oss; oss << "MEDFileField1TS(fileName,fieldName) : file \'" << fileName << "\' contains field with name \'" << fieldName << "\' but there is no time steps on it !";
5224 throw INTERP_KERNEL::Exception(oss.str().c_str());
5227 med_int numdt,numit;
5229 MEDfieldComputingStepInfo(fid,fieldName.c_str(),1,&numdt,&numit,&dt);
5230 ret->setTime(numdt,numit,dt);
5233 ret->loadStructureAndBigArraysRecursively(fid,*((const MEDFileAnyTypeField1TSWithoutSDA*)ret));
5235 ret->loadOnlyStructureOfDataRecursively(fid,*((const MEDFileAnyTypeField1TSWithoutSDA*)ret));
5239 MEDFileAnyTypeField1TS::MEDFileAnyTypeField1TS(const std::string& fileName, const std::string& fieldName, bool loadAll)
5240 try:MEDFileFieldGlobsReal(fileName)
5242 MEDFileUtilities::CheckFileForRead(fileName);
5243 MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
5244 _content=BuildContentFrom(fid,fileName,fieldName,loadAll);
5247 catch(INTERP_KERNEL::Exception& e)
5252 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::BuildNewInstanceFromContent(MEDFileAnyTypeField1TSWithoutSDA *c, const std::string& fileName)
5255 throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS::BuildNewInstanceFromContent : empty content in input : unable to build a new instance !");
5256 if(dynamic_cast<const MEDFileField1TSWithoutSDA *>(c))
5258 MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=MEDFileField1TS::New();
5259 ret->setFileName(fileName);
5260 ret->_content=c; c->incrRef();
5263 if(dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(c))
5265 MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=MEDFileIntField1TS::New();
5266 ret->setFileName(fileName);
5267 ret->_content=c; c->incrRef();
5270 throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS::BuildNewInstanceFromContent : internal error ! a content of type different from FLOAT64 and INT32 has been built but not intercepted !");
5273 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::New(const std::string& fileName, bool loadAll)
5275 MEDFileUtilities::CheckFileForRead(fileName);
5276 MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
5277 MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> c=BuildContentFrom(fid,fileName,loadAll);
5278 MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TS> ret=BuildNewInstanceFromContent(c,fileName);
5279 ret->loadGlobals(fid);
5283 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::New(const std::string& fileName, const std::string& fieldName, bool loadAll)
5285 MEDFileUtilities::CheckFileForRead(fileName);
5286 MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
5287 MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> c=BuildContentFrom(fid,fileName,fieldName,loadAll);
5288 MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TS> ret=BuildNewInstanceFromContent(c,fileName);
5289 ret->loadGlobals(fid);
5293 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::New(const std::string& fileName, const std::string& fieldName, int iteration, int order, bool loadAll)
5295 MEDFileUtilities::CheckFileForRead(fileName);
5296 MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
5297 MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> c=BuildContentFrom(fid,fileName,fieldName,iteration,order,loadAll);
5298 MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TS> ret=BuildNewInstanceFromContent(c,fileName);
5299 ret->loadGlobals(fid);
5303 MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeField1TS::BuildContentFrom(med_idt fid, const std::string& fileName, const std::string& fieldName, int iteration, int order, bool loadAll)
5305 med_field_type typcha;
5306 std::vector<std::string> infos;
5309 int nbOfStep2=LocateField(fid,fileName,fieldName,iii,typcha,infos,dtunit);
5310 MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> ret;
5315 ret=MEDFileField1TSWithoutSDA::New(fieldName,-1,iteration,order,std::vector<std::string>());
5320 ret=MEDFileIntField1TSWithoutSDA::New(fieldName,-1,iteration,order,std::vector<std::string>());
5325 std::ostringstream oss; oss << "MEDFileAnyTypeField1TS::BuildContentFrom(fileName,fieldName,iteration,order) : file \'" << fileName << "\' contains field with name \'" << fieldName << "\' but the type of field is not in [MED_FLOAT64, MED_INT32] !";
5326 throw INTERP_KERNEL::Exception(oss.str().c_str());
5329 ret->setDtUnit(dtunit.c_str());
5330 ret->getOrCreateAndGetArray()->setInfoAndChangeNbOfCompo(infos);
5333 std::vector< std::pair<int,int> > dtits(nbOfStep2);
5334 for(int i=0;i<nbOfStep2 && !found;i++)
5336 med_int numdt,numit;
5338 MEDfieldComputingStepInfo(fid,fieldName.c_str(),i+1,&numdt,&numit,&dt);
5339 if(numdt==iteration && numit==order)
5345 dtits[i]=std::pair<int,int>(numdt,numit);
5349 std::ostringstream oss; oss << "No such iteration (" << iteration << "," << order << ") in existing field '" << fieldName << "' in file '" << fileName << "' ! Available iterations are : ";
5350 for(std::vector< std::pair<int,int> >::const_iterator iter=dtits.begin();iter!=dtits.end();iter++)
5351 oss << "(" << (*iter).first << "," << (*iter).second << "), ";
5352 throw INTERP_KERNEL::Exception(oss.str().c_str());
5355 ret->loadStructureAndBigArraysRecursively(fid,*((const MEDFileAnyTypeField1TSWithoutSDA*)ret));
5357 ret->loadOnlyStructureOfDataRecursively(fid,*((const MEDFileAnyTypeField1TSWithoutSDA*)ret));
5361 MEDFileAnyTypeField1TS::MEDFileAnyTypeField1TS(const std::string& fileName, const std::string& fieldName, int iteration, int order, bool loadAll)
5362 try:MEDFileFieldGlobsReal(fileName)
5364 MEDFileUtilities::CheckFileForRead(fileName);
5365 MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
5366 _content=BuildContentFrom(fid,fileName.c_str(),fieldName.c_str(),iteration,order,loadAll);
5369 catch(INTERP_KERNEL::Exception& e)
5375 * This constructor is a shallow copy constructor. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
5376 * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
5378 * \warning this is a shallow copy constructor
5380 MEDFileAnyTypeField1TS::MEDFileAnyTypeField1TS(const MEDFileAnyTypeField1TSWithoutSDA& other, bool shallowCopyOfContent)
5382 if(!shallowCopyOfContent)
5384 const MEDFileAnyTypeField1TSWithoutSDA *otherPtr(&other);
5385 otherPtr->incrRef();
5386 _content=const_cast<MEDFileAnyTypeField1TSWithoutSDA *>(otherPtr);
5390 _content=other.shallowCpy();
5394 int MEDFileAnyTypeField1TS::LocateField2(med_idt fid, const std::string& fileName, int fieldIdCFormat, bool checkFieldId, std::string& fieldName, med_field_type& typcha, std::vector<std::string>& infos, std::string& dtunitOut)
5398 int nbFields=MEDnField(fid);
5399 if(fieldIdCFormat>=nbFields)
5401 std::ostringstream oss; oss << "MEDFileAnyTypeField1TS::LocateField2(fileName) : in file \'" << fileName << "\' number of fields is " << nbFields << " ! Trying to request for id " << fieldIdCFormat << " !";
5402 throw INTERP_KERNEL::Exception(oss.str().c_str());
5405 int ncomp=MEDfieldnComponent(fid,fieldIdCFormat+1);
5406 INTERP_KERNEL::AutoPtr<char> comp=MEDLoaderBase::buildEmptyString(ncomp*MED_SNAME_SIZE);
5407 INTERP_KERNEL::AutoPtr<char> unit=MEDLoaderBase::buildEmptyString(ncomp*MED_SNAME_SIZE);
5408 INTERP_KERNEL::AutoPtr<char> dtunit=MEDLoaderBase::buildEmptyString(MED_LNAME_SIZE);
5409 INTERP_KERNEL::AutoPtr<char> nomcha=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
5410 INTERP_KERNEL::AutoPtr<char> nomMaa=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
5413 MEDfieldInfo(fid,fieldIdCFormat+1,nomcha,nomMaa,&localMesh,&typcha,comp,unit,dtunit,&nbOfStep);
5414 fieldName=MEDLoaderBase::buildStringFromFortran(nomcha,MED_NAME_SIZE);
5415 dtunitOut=MEDLoaderBase::buildStringFromFortran(dtunit,MED_LNAME_SIZE);
5416 infos.clear(); infos.resize(ncomp);
5417 for(int j=0;j<ncomp;j++)
5418 infos[j]=MEDLoaderBase::buildUnionUnit((char *)comp+j*MED_SNAME_SIZE,MED_SNAME_SIZE,(char *)unit+j*MED_SNAME_SIZE,MED_SNAME_SIZE);
5423 * This method throws an INTERP_KERNEL::Exception if \a fieldName field is not in file pointed by \a fid and with name \a fileName.
5426 * \return in case of success the number of time steps available for the field with name \a fieldName.
5428 int MEDFileAnyTypeField1TS::LocateField(med_idt fid, const std::string& fileName, const std::string& fieldName, int& posCFormat, med_field_type& typcha, std::vector<std::string>& infos, std::string& dtunitOut)
5430 int nbFields=MEDnField(fid);
5432 std::vector<std::string> fns(nbFields);
5434 for(int i=0;i<nbFields && !found;i++)
5437 nbOfStep2=LocateField2(fid,fileName,i,false,tmp,typcha,infos,dtunitOut);
5439 found=(tmp==fieldName);
5445 std::ostringstream oss; oss << "No such field '" << fieldName << "' in file '" << fileName << "' ! Available fields are : ";
5446 for(std::vector<std::string>::const_iterator it=fns.begin();it!=fns.end();it++)
5447 oss << "\"" << *it << "\" ";
5448 throw INTERP_KERNEL::Exception(oss.str().c_str());
5454 * This method as MEDFileField1TSW::setLocNameOnLeaf, is dedicated for advanced user that a want a very fine control on their data structure
5455 * without overhead. This method can be called only regarding information returned by MEDFileField1TSWithoutSDA::getFieldSplitedByType or MEDFileField1TSWithoutSDA::getFieldSplitedByType2.
5456 * This method changes the attribute (here it's profile name) of the leaf datastructure (MEDFileFieldPerMeshPerTypePerDisc instance).
5457 * It is the responsability of the caller to invoke MEDFileFieldGlobs::appendProfile or MEDFileFieldGlobs::getProfile
5458 * to keep a valid instance.
5459 * 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.
5460 * If \b newPflName profile name does not already exist the profile with old name will be renamed with name \b newPflName.
5461 * 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.
5463 * \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.
5464 * \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.
5465 * \param [in] locId is the localization id to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set. It corresponds to the position of
5466 * \c pfls[std::distance(types.begin(),std::find(types.begin(),typ)] vector in MEDFileField1TSWithoutSDA::getFieldSplitedByType. For non gausspoints field users, the value is 0.
5467 * \param [in] newLocName is the new localization name.
5468 * \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.
5469 * If false, an exception will be thrown to force user to change previously the name of the profile with name \b newPflName
5471 void MEDFileAnyTypeField1TS::setProfileNameOnLeaf(const std::string& mName, INTERP_KERNEL::NormalizedCellType typ, int locId, const std::string& newPflName, bool forceRenameOnGlob)
5473 MEDFileFieldPerMeshPerTypePerDisc *disc=getLeafGivenMeshAndTypeAndLocId(mName,typ,locId);
5474 std::string oldPflName=disc->getProfile();
5475 std::vector<std::string> vv=getPflsReallyUsedMulti();
5476 int nbOfOcc=std::count(vv.begin(),vv.end(),oldPflName);
5477 if(forceRenameOnGlob || (!existsPfl(newPflName) && nbOfOcc==1))
5479 disc->setProfile(newPflName);
5480 DataArrayInt *pfl=getProfile(oldPflName.c_str());
5481 pfl->setName(newPflName);
5485 std::ostringstream oss; oss << "MEDFileField1TS::setProfileNameOnLeaf : Profile \"" << newPflName << "\" already exists or referenced more than one !";
5486 throw INTERP_KERNEL::Exception(oss.str().c_str());
5491 * This method as MEDFileField1TSW::setProfileNameOnLeaf, is dedicated for advanced user that a want a very fine control on their data structure
5492 * without overhead. This method can be called only regarding information returned by MEDFileField1TSWithoutSDA::getFieldSplitedByType or MEDFileField1TSWithoutSDA::getFieldSplitedByType2.
5493 * This method changes the attribute (here it's localization name) of the leaf datastructure (MEDFileFieldPerMeshPerTypePerDisc instance).
5494 * It is the responsability of the caller to invoke MEDFileFieldGlobs::appendProfile or MEDFileFieldGlobs::getProfile
5495 * to keep a valid instance.
5496 * 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.
5497 * This method is an extension of MEDFileField1TSWithoutSDA::setProfileNameOnLeafExt method because it performs a modification of global info.
5498 * If \b newLocName profile name does not already exist the localization with old name will be renamed with name \b newLocName.
5499 * 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.
5501 * \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.
5502 * \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.
5503 * \param [in] locId is the localization id to find the right MEDFileFieldPerMeshPerTypePerDisc instance to set. It corresponds to the position of
5504 * \c pfls[std::distance(types.begin(),std::find(types.begin(),typ)] vector in MEDFileField1TSWithoutSDA::getFieldSplitedByType. For non gausspoints field users, the value is 0.
5505 * \param [in] newLocName is the new localization name.
5506 * \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.
5507 * If false, an exception will be thrown to force user to change previously the name of the profile with name \b newLocName
5509 void MEDFileAnyTypeField1TS::setLocNameOnLeaf(const std::string& mName, INTERP_KERNEL::NormalizedCellType typ, int locId, const std::string& newLocName, bool forceRenameOnGlob)
5511 MEDFileFieldPerMeshPerTypePerDisc *disc=getLeafGivenMeshAndTypeAndLocId(mName,typ,locId);
5512 std::string oldLocName=disc->getLocalization();
5513 std::vector<std::string> vv=getLocsReallyUsedMulti();
5514 int nbOfOcc=std::count(vv.begin(),vv.end(),oldLocName);
5515 if(forceRenameOnGlob || (!existsLoc(newLocName) && nbOfOcc==1))
5517 disc->setLocalization(newLocName);
5518 MEDFileFieldLoc& loc=getLocalization(oldLocName.c_str());
5519 loc.setName(newLocName);
5523 std::ostringstream oss; oss << "MEDFileField1TS::setLocNameOnLeaf : Localization \"" << newLocName << "\" already exists or referenced more than one !";
5524 throw INTERP_KERNEL::Exception(oss.str().c_str());
5528 MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeField1TS::contentNotNullBase()
5530 MEDFileAnyTypeField1TSWithoutSDA *ret=_content;
5532 throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS : content is expected to be not null !");
5536 const MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeField1TS::contentNotNullBase() const
5538 const MEDFileAnyTypeField1TSWithoutSDA *ret=_content;
5540 throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS : const content is expected to be not null !");
5545 * Writes \a this field into a MED file specified by its name.
5546 * \param [in] fileName - the MED file name.
5547 * \param [in] mode - the writing mode. For more on \a mode, see \ref AdvMEDLoaderBasics.
5548 * - 2 - erase; an existing file is removed.
5549 * - 1 - append; same data should not be present in an existing file.
5550 * - 0 - overwrite; same data present in an existing file is overwritten.
5551 * \throw If the field name is not set.
5552 * \throw If no field data is set.
5553 * \throw If \a mode == 1 and the same data is present in an existing file.
5555 void MEDFileAnyTypeField1TS::write(const std::string& fileName, int mode) const
5557 med_access_mode medmod=MEDFileUtilities::TraduceWriteMode(mode);
5558 MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),medmod);
5563 * This method alloc the arrays and load potentially huge arrays contained in this field.
5564 * This method should be called when a MEDFileAnyTypeField1TS::New constructor has been with false as the last parameter.
5565 * This method can be also called to refresh or reinit values from a file.
5567 * \throw If the fileName is not set or points to a non readable MED file.
5568 * \sa MEDFileAnyTypeField1TS::loadArraysIfNecessary
5570 void MEDFileAnyTypeField1TS::loadArrays()
5572 if(getFileName().empty())
5573 throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS::loadArrays : the structure does not come from a file !");
5574 MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName().c_str(),MED_ACC_RDONLY);
5575 contentNotNullBase()->loadBigArraysRecursively(fid,*contentNotNullBase());
5579 * This method behaves as MEDFileAnyTypeField1TS::loadArrays does, the first call, if \a this was built using a file without loading big arrays.
5580 * But once data loaded once, this method does nothing. Contrary to MEDFileAnyTypeField1TS::loadArrays and MEDFileAnyTypeField1TS::unloadArrays
5581 * this method does not throw if \a this does not come from file read.
5583 * \sa MEDFileAnyTypeField1TS::loadArrays, MEDFileAnyTypeField1TS::unloadArrays
5585 void MEDFileAnyTypeField1TS::loadArraysIfNecessary()
5587 if(!getFileName().empty())
5589 MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName().c_str(),MED_ACC_RDONLY);
5590 contentNotNullBase()->loadBigArraysRecursivelyIfNecessary(fid,*contentNotNullBase());
5595 * This method releases potentially big data arrays and so returns to the same heap memory than status loaded with 'loadAll' parameter set to false.
5596 * \b WARNING, this method does release arrays even if \a this does not come from a load of a MED file.
5597 * So this method can lead to a loss of data. If you want to unload arrays safely call MEDFileAnyTypeField1TS::unloadArraysWithoutDataLoss instead.
5599 * \sa MEDFileAnyTypeField1TS::loadArrays, MEDFileAnyTypeField1TS::loadArraysIfNecessary, MEDFileAnyTypeField1TS::unloadArraysWithoutDataLoss
5601 void MEDFileAnyTypeField1TS::unloadArrays()
5603 contentNotNullBase()->unloadArrays();
5607 * 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.
5608 * This method is the symetrical method of MEDFileAnyTypeField1TS::loadArraysIfNecessary.
5609 * This method is useful to reduce \b safely amount of heap memory necessary for \a this by using MED file as database.
5611 * \sa MEDFileAnyTypeField1TS::loadArraysIfNecessary
5613 void MEDFileAnyTypeField1TS::unloadArraysWithoutDataLoss()
5615 if(!getFileName().empty())
5616 contentNotNullBase()->unloadArrays();
5619 void MEDFileAnyTypeField1TS::writeLL(med_idt fid) const
5621 int nbComp=getNumberOfComponents();
5622 INTERP_KERNEL::AutoPtr<char> comp=MEDLoaderBase::buildEmptyString(nbComp*MED_SNAME_SIZE);
5623 INTERP_KERNEL::AutoPtr<char> unit=MEDLoaderBase::buildEmptyString(nbComp*MED_SNAME_SIZE);
5624 for(int i=0;i<nbComp;i++)
5626 std::string info=getInfo()[i];
5628 MEDLoaderBase::splitIntoNameAndUnit(info,c,u);
5629 MEDLoaderBase::safeStrCpy2(c.c_str(),MED_SNAME_SIZE,comp+i*MED_SNAME_SIZE,_too_long_str);
5630 MEDLoaderBase::safeStrCpy2(u.c_str(),MED_SNAME_SIZE,unit+i*MED_SNAME_SIZE,_too_long_str);
5632 if(getName().empty())
5633 throw INTERP_KERNEL::Exception("MEDFileField1TS::write : MED file does not accept field with empty name !");
5634 MEDfieldCr(fid,getName().c_str(),getMEDFileFieldType(),nbComp,comp,unit,getDtUnit().c_str(),getMeshName().c_str());
5635 writeGlobals(fid,*this);
5636 contentNotNullBase()->writeLL(fid,*this,*contentNotNullBase());
5639 std::size_t MEDFileAnyTypeField1TS::getHeapMemorySizeWithoutChildren() const
5641 return MEDFileFieldGlobsReal::getHeapMemorySizeWithoutChildren();
5644 std::vector<const BigMemoryObject *> MEDFileAnyTypeField1TS::getDirectChildren() const
5646 std::vector<const BigMemoryObject *> ret(MEDFileFieldGlobsReal::getDirectChildren());
5647 if((const MEDFileAnyTypeField1TSWithoutSDA *)_content)
5648 ret.push_back((const MEDFileAnyTypeField1TSWithoutSDA *)_content);
5653 * Returns a string describing \a this field. This string is outputted
5654 * by \c print Python command.
5656 std::string MEDFileAnyTypeField1TS::simpleRepr() const
5658 std::ostringstream oss;
5659 contentNotNullBase()->simpleRepr(0,oss,-1);
5660 simpleReprGlobs(oss);
5665 * This method returns all profiles whose name is non empty used.
5666 * \b WARNING If profile is used several times it will be reported \b only \b once.
5667 * To get non empty name profiles as time as they appear in \b this call MEDFileField1TS::getPflsReallyUsedMulti instead.
5669 std::vector<std::string> MEDFileAnyTypeField1TS::getPflsReallyUsed() const
5671 return contentNotNullBase()->getPflsReallyUsed2();
5675 * This method returns all localizations whose name is non empty used.
5676 * \b WARNING If localization is used several times it will be reported \b only \b once.
5678 std::vector<std::string> MEDFileAnyTypeField1TS::getLocsReallyUsed() const
5680 return contentNotNullBase()->getLocsReallyUsed2();
5684 * This method returns all profiles whose name is non empty used.
5685 * \b WARNING contrary to MEDFileField1TS::getPflsReallyUsed, if profile is used several times it will be reported as time as it appears.
5687 std::vector<std::string> MEDFileAnyTypeField1TS::getPflsReallyUsedMulti() const
5689 return contentNotNullBase()->getPflsReallyUsedMulti2();
5693 * This method returns all localizations whose name is non empty used.
5694 * \b WARNING contrary to MEDFileField1TS::getLocsReallyUsed if localization is used several times it will be reported as time as it appears.
5696 std::vector<std::string> MEDFileAnyTypeField1TS::getLocsReallyUsedMulti() const
5698 return contentNotNullBase()->getLocsReallyUsedMulti2();
5701 void MEDFileAnyTypeField1TS::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
5703 contentNotNullBase()->changePflsRefsNamesGen2(mapOfModif);
5706 void MEDFileAnyTypeField1TS::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
5708 contentNotNullBase()->changeLocsRefsNamesGen2(mapOfModif);
5711 int MEDFileAnyTypeField1TS::getDimension() const
5713 return contentNotNullBase()->getDimension();
5716 int MEDFileAnyTypeField1TS::getIteration() const
5718 return contentNotNullBase()->getIteration();
5721 int MEDFileAnyTypeField1TS::getOrder() const
5723 return contentNotNullBase()->getOrder();
5726 double MEDFileAnyTypeField1TS::getTime(int& iteration, int& order) const
5728 return contentNotNullBase()->getTime(iteration,order);
5731 void MEDFileAnyTypeField1TS::setTime(int iteration, int order, double val)
5733 contentNotNullBase()->setTime(iteration,order,val);
5736 std::string MEDFileAnyTypeField1TS::getName() const
5738 return contentNotNullBase()->getName();
5741 void MEDFileAnyTypeField1TS::setName(const std::string& name)
5743 contentNotNullBase()->setName(name);
5746 void MEDFileAnyTypeField1TS::simpleRepr(int bkOffset, std::ostream& oss, int f1tsId) const
5748 contentNotNullBase()->simpleRepr(bkOffset,oss,f1tsId);
5751 std::string MEDFileAnyTypeField1TS::getDtUnit() const
5753 return contentNotNullBase()->getDtUnit();
5756 void MEDFileAnyTypeField1TS::setDtUnit(const std::string& dtUnit)
5758 contentNotNullBase()->setDtUnit(dtUnit);
5761 std::string MEDFileAnyTypeField1TS::getMeshName() const
5763 return contentNotNullBase()->getMeshName();
5766 void MEDFileAnyTypeField1TS::setMeshName(const std::string& newMeshName)
5768 contentNotNullBase()->setMeshName(newMeshName);
5771 bool MEDFileAnyTypeField1TS::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab)
5773 return contentNotNullBase()->changeMeshNames(modifTab);
5776 int MEDFileAnyTypeField1TS::getMeshIteration() const
5778 return contentNotNullBase()->getMeshIteration();
5781 int MEDFileAnyTypeField1TS::getMeshOrder() const
5783 return contentNotNullBase()->getMeshOrder();
5786 int MEDFileAnyTypeField1TS::getNumberOfComponents() const
5788 return contentNotNullBase()->getNumberOfComponents();
5791 bool MEDFileAnyTypeField1TS::isDealingTS(int iteration, int order) const
5793 return contentNotNullBase()->isDealingTS(iteration,order);
5796 std::pair<int,int> MEDFileAnyTypeField1TS::getDtIt() const
5798 return contentNotNullBase()->getDtIt();
5801 void MEDFileAnyTypeField1TS::fillIteration(std::pair<int,int>& p) const
5803 contentNotNullBase()->fillIteration(p);
5806 void MEDFileAnyTypeField1TS::fillTypesOfFieldAvailable(std::vector<TypeOfField>& types) const
5808 contentNotNullBase()->fillTypesOfFieldAvailable(types);
5811 void MEDFileAnyTypeField1TS::setInfo(const std::vector<std::string>& infos)
5813 contentNotNullBase()->setInfo(infos);
5816 const std::vector<std::string>& MEDFileAnyTypeField1TS::getInfo() const
5818 return contentNotNullBase()->getInfo();
5820 std::vector<std::string>& MEDFileAnyTypeField1TS::getInfo()
5822 return contentNotNullBase()->getInfo();
5825 MEDFileFieldPerMeshPerTypePerDisc *MEDFileAnyTypeField1TS::getLeafGivenMeshAndTypeAndLocId(const std::string& mName, INTERP_KERNEL::NormalizedCellType typ, int locId)
5827 return contentNotNullBase()->getLeafGivenMeshAndTypeAndLocId(mName,typ,locId);
5830 const MEDFileFieldPerMeshPerTypePerDisc *MEDFileAnyTypeField1TS::getLeafGivenMeshAndTypeAndLocId(const std::string& mName, INTERP_KERNEL::NormalizedCellType typ, int locId) const
5832 return contentNotNullBase()->getLeafGivenMeshAndTypeAndLocId(mName,typ,locId);
5835 int MEDFileAnyTypeField1TS::getNonEmptyLevels(const std::string& mname, std::vector<int>& levs) const
5837 return contentNotNullBase()->getNonEmptyLevels(mname,levs);
5840 std::vector<TypeOfField> MEDFileAnyTypeField1TS::getTypesOfFieldAvailable() const
5842 return contentNotNullBase()->getTypesOfFieldAvailable();
5845 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,
5846 std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> >& locs) const throw(INTERP_KERNEL::Exception)
5848 return contentNotNullBase()->getFieldSplitedByType(mname,types,typesF,pfls,locs);
5852 * This method returns as MEDFileAnyTypeField1TS new instances as number of components in \a this.
5853 * The returned instances are deep copy of \a this except that for globals that are share with those contained in \a this.
5854 * ** WARNING ** do no forget to rename the ouput instances to avoid to write n-times in the same MED file field !
5856 std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TS > > MEDFileAnyTypeField1TS::splitComponents() const
5858 const MEDFileAnyTypeField1TSWithoutSDA *content(_content);
5860 throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS::splitComponents : no content in this ! Unable to split components !");
5861 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > contentsSplit=content->splitComponents();
5862 std::size_t sz(contentsSplit.size());
5863 std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TS > > ret(sz);
5864 for(std::size_t i=0;i<sz;i++)
5866 ret[i]=shallowCpy();
5867 ret[i]->_content=contentsSplit[i];
5873 * This method returns as MEDFileAnyTypeField1TS new instances as number of spatial discretizations in \a this.
5874 * The returned instances are deep copy of \a this except that for globals that are share with those contained in \a this.
5876 std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TS > > MEDFileAnyTypeField1TS::splitDiscretizations() const
5878 const MEDFileAnyTypeField1TSWithoutSDA *content(_content);
5880 throw INTERP_KERNEL::Exception("MEDFileAnyTypeField1TS::splitDiscretizations : no content in this ! Unable to split discretization !");
5881 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > contentsSplit=content->splitDiscretizations();
5882 std::size_t sz(contentsSplit.size());
5883 std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TS > > ret(sz);
5884 for(std::size_t i=0;i<sz;i++)
5886 ret[i]=shallowCpy();
5887 ret[i]->_content=contentsSplit[i];
5892 MEDFileAnyTypeField1TS *MEDFileAnyTypeField1TS::deepCpy() const
5894 MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TS> ret=shallowCpy();
5895 if((const MEDFileAnyTypeField1TSWithoutSDA *)_content)
5896 ret->_content=_content->deepCpy();
5897 ret->deepCpyGlobs(*this);
5901 int MEDFileAnyTypeField1TS::copyTinyInfoFrom(const MEDCouplingFieldDouble *field, const DataArray *arr)
5903 return contentNotNullBase()->copyTinyInfoFrom(field,arr);
5909 * Returns a new instance of MEDFileField1TS holding data of the first time step of
5910 * the first field that has been read from a specified MED file.
5911 * \param [in] fileName - the name of the MED file to read.
5912 * \return MEDFileField1TS * - a new instance of MEDFileFieldMultiTS. The caller
5913 * is to delete this field using decrRef() as it is no more needed.
5914 * \throw If reading the file fails.
5916 MEDFileField1TS *MEDFileField1TS::New(const std::string& fileName, bool loadAll)
5918 MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=new MEDFileField1TS(fileName,loadAll);
5919 ret->contentNotNull();
5924 * Returns a new instance of MEDFileField1TS holding data of the first time step of
5925 * a given field that has been read from a specified MED file.
5926 * \param [in] fileName - the name of the MED file to read.
5927 * \param [in] fieldName - the name of the field to read.
5928 * \return MEDFileField1TS * - a new instance of MEDFileFieldMultiTS. The caller
5929 * is to delete this field using decrRef() as it is no more needed.
5930 * \throw If reading the file fails.
5931 * \throw If there is no field named \a fieldName in the file.
5933 MEDFileField1TS *MEDFileField1TS::New(const std::string& fileName, const std::string& fieldName, bool loadAll)
5935 MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=new MEDFileField1TS(fileName,fieldName,loadAll);
5936 ret->contentNotNull();
5941 * Returns a new instance of MEDFileField1TS holding data of a given time step of
5942 * a given field that has been read from a specified MED file.
5943 * \param [in] fileName - the name of the MED file to read.
5944 * \param [in] fieldName - the name of the field to read.
5945 * \param [in] iteration - the iteration number of a required time step.
5946 * \param [in] order - the iteration order number of required time step.
5947 * \return MEDFileField1TS * - a new instance of MEDFileFieldMultiTS. The caller
5948 * is to delete this field using decrRef() as it is no more needed.
5949 * \throw If reading the file fails.
5950 * \throw If there is no field named \a fieldName in the file.
5951 * \throw If the required time step is missing from the file.
5953 MEDFileField1TS *MEDFileField1TS::New(const std::string& fileName, const std::string& fieldName, int iteration, int order, bool loadAll)
5955 MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=new MEDFileField1TS(fileName,fieldName,iteration,order,loadAll);
5956 ret->contentNotNull();
5961 * Returns a new instance of MEDFileField1TS. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
5962 * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
5964 * Returns a new instance of MEDFileField1TS holding either a shallow copy
5965 * of a given MEDFileField1TSWithoutSDA ( \a other ) or \a other itself.
5966 * \warning this is a shallow copy constructor
5967 * \param [in] other - a MEDFileField1TSWithoutSDA to copy.
5968 * \param [in] shallowCopyOfContent - if \c true, a shallow copy of \a other is created.
5969 * \return MEDFileField1TS * - a new instance of MEDFileField1TS. The caller
5970 * is to delete this field using decrRef() as it is no more needed.
5972 MEDFileField1TS *MEDFileField1TS::New(const MEDFileField1TSWithoutSDA& other, bool shallowCopyOfContent)
5974 MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=new MEDFileField1TS(other,shallowCopyOfContent);
5975 ret->contentNotNull();
5980 * Returns a new empty instance of MEDFileField1TS.
5981 * \return MEDFileField1TS * - a new instance of MEDFileField1TS. The caller
5982 * is to delete this field using decrRef() as it is no more needed.
5984 MEDFileField1TS *MEDFileField1TS::New()
5986 MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=new MEDFileField1TS;
5987 ret->contentNotNull();
5992 * This method performs a copy with datatype modification ( float64->int32 ) of \a this. The globals information are copied
5993 * following the given input policy.
5995 * \param [in] isDeepCpyGlobs - a boolean that indicates the behaviour concerning globals (profiles and localizations)
5996 * By default (true) the globals are deeply copied.
5997 * \return MEDFileIntField1TS * - a new object that is the result of the conversion of \a this to int32 field.
5999 MEDFileIntField1TS *MEDFileField1TS::convertToInt(bool isDeepCpyGlobs) const
6001 MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret;
6002 const MEDFileAnyTypeField1TSWithoutSDA *content(_content);
6005 const MEDFileField1TSWithoutSDA *contc=dynamic_cast<const MEDFileField1TSWithoutSDA *>(content);
6007 throw INTERP_KERNEL::Exception("MEDFileField1TS::convertToInt : the content inside this is not FLOAT64 ! This is incoherent !");
6008 MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TSWithoutSDA> newc(contc->convertToInt());
6009 ret=static_cast<MEDFileIntField1TS *>(MEDFileAnyTypeField1TS::BuildNewInstanceFromContent((MEDFileIntField1TSWithoutSDA *)newc,getFileName()));
6012 ret=MEDFileIntField1TS::New();
6014 ret->deepCpyGlobs(*this);
6016 ret->shallowCpyGlobs(*this);
6020 const MEDFileField1TSWithoutSDA *MEDFileField1TS::contentNotNull() const
6022 const MEDFileAnyTypeField1TSWithoutSDA *pt(_content);
6024 throw INTERP_KERNEL::Exception("MEDFileField1TS::contentNotNull : the content pointer is null !");
6025 const MEDFileField1TSWithoutSDA *ret=dynamic_cast<const MEDFileField1TSWithoutSDA *>(pt);
6027 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 !");
6031 MEDFileField1TSWithoutSDA *MEDFileField1TS::contentNotNull()
6033 MEDFileAnyTypeField1TSWithoutSDA *pt(_content);
6035 throw INTERP_KERNEL::Exception("MEDFileField1TS::contentNotNull : the non const content pointer is null !");
6036 MEDFileField1TSWithoutSDA *ret=dynamic_cast<MEDFileField1TSWithoutSDA *>(pt);
6038 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 !");
6042 void MEDFileField1TS::SetDataArrayDoubleInField(MEDCouplingFieldDouble *f, MEDCouplingAutoRefCountObjectPtr<DataArray>& arr)
6045 throw INTERP_KERNEL::Exception("MEDFileField1TS::SetDataArrayDoubleInField : input field is NULL !");
6046 if(!((DataArray*)arr))
6047 throw INTERP_KERNEL::Exception("MEDFileField1TS::SetDataArrayDoubleInField : no array !");
6048 DataArrayDouble *arrOutC=dynamic_cast<DataArrayDouble *>((DataArray*)arr);
6050 throw INTERP_KERNEL::Exception("MEDFileField1TS::SetDataArrayDoubleInField : mismatch between dataArrays type and MEDFileField1TS ! Expected double !");
6051 f->setArray(arrOutC);
6054 DataArrayDouble *MEDFileField1TS::ReturnSafelyDataArrayDouble(MEDCouplingAutoRefCountObjectPtr<DataArray>& arr)
6056 if(!((DataArray*)arr))
6057 throw INTERP_KERNEL::Exception("MEDFileField1TS::ReturnSafelyDataArrayDouble : no array !");
6058 DataArrayDouble *arrOutC=dynamic_cast<DataArrayDouble *>((DataArray*)arr);
6060 throw INTERP_KERNEL::Exception("MEDFileField1TS::ReturnSafelyDataArrayDouble : mismatch between dataArrays type and MEDFileField1TS ! Expected double !");
6065 MEDFileField1TS::MEDFileField1TS(const std::string& fileName, bool loadAll)
6066 try:MEDFileAnyTypeField1TS(fileName,loadAll)
6069 catch(INTERP_KERNEL::Exception& e)
6072 MEDFileField1TS::MEDFileField1TS(const std::string& fileName, const std::string& fieldName, bool loadAll)
6073 try:MEDFileAnyTypeField1TS(fileName,fieldName,loadAll)
6076 catch(INTERP_KERNEL::Exception& e)
6079 MEDFileField1TS::MEDFileField1TS(const std::string& fileName, const std::string& fieldName, int iteration, int order, bool loadAll)
6080 try:MEDFileAnyTypeField1TS(fileName,fieldName,iteration,order,loadAll)
6083 catch(INTERP_KERNEL::Exception& e)
6087 * This constructor is a shallow copy constructor. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
6088 * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
6090 * \warning this is a shallow copy constructor
6092 MEDFileField1TS::MEDFileField1TS(const MEDFileField1TSWithoutSDA& other, bool shallowCopyOfContent)
6093 try:MEDFileAnyTypeField1TS(other,shallowCopyOfContent)
6096 catch(INTERP_KERNEL::Exception& e)
6099 MEDFileField1TS::MEDFileField1TS()
6101 _content=new MEDFileField1TSWithoutSDA;
6105 * Returns a new MEDCouplingFieldDouble of a given type lying on
6106 * mesh entities of a given dimension of the first mesh in MED file. If \a this field
6107 * has not been constructed via file reading, an exception is thrown.
6108 * For more info, see \ref AdvMEDLoaderAPIFieldRW
6109 * \param [in] type - a spatial discretization of interest.
6110 * \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6111 * \param [in] renumPol - specifies how to permute values of the result field according to
6112 * the optional numbers of cells and nodes, if any. The valid values are
6113 * - 0 - do not permute.
6114 * - 1 - permute cells.
6115 * - 2 - permute nodes.
6116 * - 3 - permute cells and nodes.
6118 * \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6119 * caller is to delete this field using decrRef() as it is no more needed.
6120 * \throw If \a this field has not been constructed via file reading.
6121 * \throw If the MED file is not readable.
6122 * \throw If there is no mesh in the MED file.
6123 * \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
6124 * \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6125 * \sa getFieldOnMeshAtLevel()
6127 MEDCouplingFieldDouble *MEDFileField1TS::getFieldAtLevel(TypeOfField type, int meshDimRelToMax, int renumPol) const
6129 if(getFileName().empty())
6130 throw INTERP_KERNEL::Exception("MEDFileField1TS::getFieldAtLevel : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtLevel method instead !");
6131 MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
6132 MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldAtLevel(type,meshDimRelToMax,std::string(),renumPol,this,arrOut,*contentNotNull());
6133 MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
6138 * Returns a new MEDCouplingFieldDouble of a given type lying on
6139 * the top level cells of the first mesh in MED file. If \a this field
6140 * has not been constructed via file reading, an exception is thrown.
6141 * For more info, see \ref AdvMEDLoaderAPIFieldRW
6142 * \param [in] type - a spatial discretization of interest.
6143 * \param [in] renumPol - specifies how to permute values of the result field according to
6144 * the optional numbers of cells and nodes, if any. The valid values are
6145 * - 0 - do not permute.
6146 * - 1 - permute cells.
6147 * - 2 - permute nodes.
6148 * - 3 - permute cells and nodes.
6150 * \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6151 * caller is to delete this field using decrRef() as it is no more needed.
6152 * \throw If \a this field has not been constructed via file reading.
6153 * \throw If the MED file is not readable.
6154 * \throw If there is no mesh in the MED file.
6155 * \throw If no field values of the given \a type.
6156 * \throw If no field values lying on the top level support.
6157 * \sa getFieldAtLevel()
6159 MEDCouplingFieldDouble *MEDFileField1TS::getFieldAtTopLevel(TypeOfField type, int renumPol) const
6161 if(getFileName().empty())
6162 throw INTERP_KERNEL::Exception("MEDFileField1TS::getFieldAtTopLevel : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtTopLevel method instead !");
6163 MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
6164 MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldAtTopLevel(type,std::string(),renumPol,this,arrOut,*contentNotNull());
6165 MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
6170 * Returns a new MEDCouplingFieldDouble of given type lying on a given mesh.
6171 * For more info, see \ref AdvMEDLoaderAPIFieldRW
6172 * \param [in] type - a spatial discretization of the new field.
6173 * \param [in] mesh - the supporting mesh.
6174 * \param [in] renumPol - specifies how to permute values of the result field according to
6175 * the optional numbers of cells and nodes, if any. The valid values are
6176 * - 0 - do not permute.
6177 * - 1 - permute cells.
6178 * - 2 - permute nodes.
6179 * - 3 - permute cells and nodes.
6181 * \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6182 * caller is to delete this field using decrRef() as it is no more needed.
6183 * \throw If no field of \a this is lying on \a mesh.
6184 * \throw If the mesh is empty.
6185 * \throw If no field values of the given \a type are available.
6186 * \sa getFieldAtLevel()
6187 * \sa getFieldOnMeshAtLevel()
6189 MEDCouplingFieldDouble *MEDFileField1TS::getFieldOnMeshAtLevel(TypeOfField type, const MEDCouplingMesh *mesh, int renumPol) const
6191 MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
6192 MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldOnMeshAtLevel(type,renumPol,this,mesh,0,0,arrOut,*contentNotNull());
6193 MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
6198 * Returns a new MEDCouplingFieldDouble of a given type lying on a given support.
6199 * For more info, see \ref AdvMEDLoaderAPIFieldRW
6200 * \param [in] type - a spatial discretization of interest.
6201 * \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6202 * \param [in] mesh - the supporting mesh.
6203 * \param [in] renumPol - specifies how to permute values of the result field according to
6204 * the optional numbers of cells and nodes, if any. The valid values are
6205 * - 0 - do not permute.
6206 * - 1 - permute cells.
6207 * - 2 - permute nodes.
6208 * - 3 - permute cells and nodes.
6210 * \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6211 * caller is to delete this field using decrRef() as it is no more needed.
6212 * \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
6213 * \throw If no field of \a this is lying on \a mesh.
6214 * \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6215 * \sa getFieldAtLevel()
6216 * \sa getFieldOnMeshAtLevel()
6218 MEDCouplingFieldDouble *MEDFileField1TS::getFieldOnMeshAtLevel(TypeOfField type, int meshDimRelToMax, const MEDFileMesh *mesh, int renumPol) const
6220 MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
6221 MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,this,mesh,arrOut,*contentNotNull());
6222 MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
6227 * Returns a new MEDCouplingFieldDouble of a given type lying on a given support.
6228 * This method is called "Old" because in MED3 norm a field has only one meshName
6229 * attached, so this method is for readers of MED2 files. If \a this field
6230 * has not been constructed via file reading, an exception is thrown.
6231 * For more info, see \ref AdvMEDLoaderAPIFieldRW
6232 * \param [in] type - a spatial discretization of interest.
6233 * \param [in] mName - a name of the supporting mesh.
6234 * \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6235 * \param [in] renumPol - specifies how to permute values of the result field according to
6236 * the optional numbers of cells and nodes, if any. The valid values are
6237 * - 0 - do not permute.
6238 * - 1 - permute cells.
6239 * - 2 - permute nodes.
6240 * - 3 - permute cells and nodes.
6242 * \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6243 * caller is to delete this field using decrRef() as it is no more needed.
6244 * \throw If the MED file is not readable.
6245 * \throw If there is no mesh named \a mName in the MED file.
6246 * \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
6247 * \throw If \a this field has not been constructed via file reading.
6248 * \throw If no field of \a this is lying on the mesh named \a mName.
6249 * \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6250 * \sa getFieldAtLevel()
6252 MEDCouplingFieldDouble *MEDFileField1TS::getFieldAtLevelOld(TypeOfField type, const std::string& mname, int meshDimRelToMax, int renumPol) const
6254 if(getFileName().empty())
6255 throw INTERP_KERNEL::Exception("MEDFileField1TS::getFieldAtLevelOld : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtLevel method instead !");
6256 MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
6257 MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldAtLevel(type,meshDimRelToMax,mname,renumPol,this,arrOut,*contentNotNull());
6258 MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
6263 * Returns values and a profile of the field of a given type lying on a given support.
6264 * For more info, see \ref AdvMEDLoaderAPIFieldRW
6265 * \param [in] type - a spatial discretization of the field.
6266 * \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6267 * \param [in] mesh - the supporting mesh.
6268 * \param [out] pfl - a new instance of DataArrayInt holding ids of mesh entities the
6269 * field of interest lies on. If the field lies on all entities of the given
6270 * dimension, all ids in \a pfl are zero. The caller is to delete this array
6271 * using decrRef() as it is no more needed.
6272 * \return DataArrayDouble * - a new instance of DataArrayDouble holding values of the
6273 * field. The caller is to delete this array using decrRef() as it is no more needed.
6274 * \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
6275 * \throw If no field of \a this is lying on \a mesh.
6276 * \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6278 DataArrayDouble *MEDFileField1TS::getFieldWithProfile(TypeOfField type, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt *&pfl) const
6280 MEDCouplingAutoRefCountObjectPtr<DataArray> ret=contentNotNull()->getFieldWithProfile(type,meshDimRelToMax,mesh,pfl,this,*contentNotNull());
6281 return MEDFileField1TS::ReturnSafelyDataArrayDouble(ret);
6285 * Adds a MEDCouplingFieldDouble to \a this. The underlying mesh of the given field is
6286 * checked if its elements are sorted suitable for writing to MED file ("STB" stands for
6287 * "Sort By Type"), if not, an exception is thrown.
6288 * For more info, see \ref AdvMEDLoaderAPIFieldRW
6289 * \param [in] field - the field to add to \a this.
6290 * \throw If the name of \a field is empty.
6291 * \throw If the data array of \a field is not set.
6292 * \throw If the data array is already allocated but has different number of components
6294 * \throw If the underlying mesh of \a field has no name.
6295 * \throw If elements in the mesh are not in the order suitable for writing to the MED file.
6297 void MEDFileField1TS::setFieldNoProfileSBT(const MEDCouplingFieldDouble *field)
6300 contentNotNull()->setFieldNoProfileSBT(field,field->getArray(),*this,*contentNotNull());
6304 * Adds a MEDCouplingFieldDouble to \a this. As described in \ref MEDLoaderMainC a field in MED file sense
6305 * can be an aggregation of several MEDCouplingFieldDouble instances.
6306 * The mesh support of input parameter \a field is ignored here, it can be NULL.
6307 * The support of field \a field is expected to be those computed with the input parameter \a mesh, \a meshDimRelToMax,
6310 * This method will check that the field based on the computed support is coherent. If not an exception will be thrown.
6311 * A new profile is added only if no equal profile is missing.
6312 * For more info, see \ref AdvMEDLoaderAPIFieldRW
6313 * \param [in] field - the field to add to \a this. The mesh support of field is ignored.
6314 * \param [in] mesh - the supporting mesh of \a field.
6315 * \param [in] meshDimRelToMax - a relative dimension of mesh entities \a field lies on (useless if field spatial discretization is ON_NODES).
6316 * \param [in] profile - ids of mesh entities on which corresponding field values lie.
6317 * \throw If either \a field or \a mesh or \a profile has an empty name.
6318 * \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
6319 * \throw If the data array of \a field is not set.
6320 * \throw If the data array of \a this is already allocated but has different number of
6321 * components than \a field.
6322 * \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
6323 * \sa setFieldNoProfileSBT()
6325 void MEDFileField1TS::setFieldProfile(const MEDCouplingFieldDouble *field, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile)
6328 contentNotNull()->setFieldProfile(field,field->getArray(),mesh,meshDimRelToMax,profile,*this,*contentNotNull());
6331 MEDFileAnyTypeField1TS *MEDFileField1TS::shallowCpy() const
6333 return new MEDFileField1TS(*this);
6336 DataArrayDouble *MEDFileField1TS::getUndergroundDataArray() const
6338 return contentNotNull()->getUndergroundDataArrayDouble();
6341 DataArrayDouble *MEDFileField1TS::getUndergroundDataArrayExt(std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
6343 return contentNotNull()->getUndergroundDataArrayDoubleExt(entries);
6346 std::vector< std::vector<DataArrayDouble *> > MEDFileField1TS::getFieldSplitedByType2(const std::string& mname, std::vector<INTERP_KERNEL::NormalizedCellType>& types, std::vector< std::vector<TypeOfField> >& typesF,
6347 std::vector< std::vector<std::string> >& pfls, std::vector< std::vector<std::string> >& locs) const throw(INTERP_KERNEL::Exception)
6349 return contentNotNull()->getFieldSplitedByType2(mname,types,typesF,pfls,locs);
6352 //= MEDFileIntField1TS
6354 MEDFileIntField1TS *MEDFileIntField1TS::New()
6356 MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=new MEDFileIntField1TS;
6357 ret->contentNotNull();
6361 MEDFileIntField1TS *MEDFileIntField1TS::New(const std::string& fileName, bool loadAll)
6363 MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=new MEDFileIntField1TS(fileName,loadAll);
6364 ret->contentNotNull();
6368 MEDFileIntField1TS *MEDFileIntField1TS::New(const std::string& fileName, const std::string& fieldName, bool loadAll)
6370 MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=new MEDFileIntField1TS(fileName,fieldName,loadAll);
6371 ret->contentNotNull();
6375 MEDFileIntField1TS *MEDFileIntField1TS::New(const std::string& fileName, const std::string& fieldName, int iteration, int order, bool loadAll)
6377 MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=new MEDFileIntField1TS(fileName,fieldName,iteration,order,loadAll);
6378 ret->contentNotNull();
6382 MEDFileIntField1TS *MEDFileIntField1TS::New(const MEDFileIntField1TSWithoutSDA& other, bool shallowCopyOfContent)
6384 MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=new MEDFileIntField1TS(other,shallowCopyOfContent);
6385 ret->contentNotNull();
6389 MEDFileIntField1TS::MEDFileIntField1TS()
6391 _content=new MEDFileIntField1TSWithoutSDA;
6394 MEDFileIntField1TS::MEDFileIntField1TS(const std::string& fileName, bool loadAll)
6395 try:MEDFileAnyTypeField1TS(fileName,loadAll)
6398 catch(INTERP_KERNEL::Exception& e)
6401 MEDFileIntField1TS::MEDFileIntField1TS(const std::string& fileName, const std::string& fieldName, bool loadAll)
6402 try:MEDFileAnyTypeField1TS(fileName,fieldName,loadAll)
6405 catch(INTERP_KERNEL::Exception& e)
6408 MEDFileIntField1TS::MEDFileIntField1TS(const std::string& fileName, const std::string& fieldName, int iteration, int order, bool loadAll)
6409 try:MEDFileAnyTypeField1TS(fileName,fieldName,iteration,order,loadAll)
6412 catch(INTERP_KERNEL::Exception& e)
6416 * This constructor is a shallow copy constructor. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
6417 * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
6419 * \warning this is a shallow copy constructor
6421 MEDFileIntField1TS::MEDFileIntField1TS(const MEDFileIntField1TSWithoutSDA& other, bool shallowCopyOfContent):MEDFileAnyTypeField1TS(other,shallowCopyOfContent)
6425 MEDFileAnyTypeField1TS *MEDFileIntField1TS::shallowCpy() const
6427 return new MEDFileIntField1TS(*this);
6431 * This method performs a copy with datatype modification ( int32->float64 ) of \a this. The globals information are copied
6432 * following the given input policy.
6434 * \param [in] isDeepCpyGlobs - a boolean that indicates the behaviour concerning globals (profiles and localizations)
6435 * By default (true) the globals are deeply copied.
6436 * \return MEDFileField1TS * - a new object that is the result of the conversion of \a this to float64 field.
6438 MEDFileField1TS *MEDFileIntField1TS::convertToDouble(bool isDeepCpyGlobs) const
6440 MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret;
6441 const MEDFileAnyTypeField1TSWithoutSDA *content(_content);
6444 const MEDFileIntField1TSWithoutSDA *contc=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(content);
6446 throw INTERP_KERNEL::Exception("MEDFileIntField1TS::convertToInt : the content inside this is not INT32 ! This is incoherent !");
6447 MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA> newc(contc->convertToDouble());
6448 ret=static_cast<MEDFileField1TS *>(MEDFileAnyTypeField1TS::BuildNewInstanceFromContent((MEDFileField1TSWithoutSDA *)newc,getFileName()));
6451 ret=MEDFileField1TS::New();
6453 ret->deepCpyGlobs(*this);
6455 ret->shallowCpyGlobs(*this);
6460 * Adds a MEDCouplingFieldDouble to \a this. The underlying mesh of the given field is
6461 * checked if its elements are sorted suitable for writing to MED file ("STB" stands for
6462 * "Sort By Type"), if not, an exception is thrown.
6463 * For more info, see \ref AdvMEDLoaderAPIFieldRW
6464 * \param [in] field - the field to add to \a this. The field double values are ignored.
6465 * \param [in] arrOfVals - the values of the field \a field used.
6466 * \throw If the name of \a field is empty.
6467 * \throw If the data array of \a field is not set.
6468 * \throw If the data array is already allocated but has different number of components
6470 * \throw If the underlying mesh of \a field has no name.
6471 * \throw If elements in the mesh are not in the order suitable for writing to the MED file.
6473 void MEDFileIntField1TS::setFieldNoProfileSBT(const MEDCouplingFieldDouble *field, const DataArrayInt *arrOfVals)
6476 contentNotNull()->setFieldNoProfileSBT(field,arrOfVals,*this,*contentNotNull());
6480 * Adds a MEDCouplingFieldDouble to \a this. As described in \ref MEDLoaderMainC a field in MED file sense
6481 * can be an aggregation of several MEDCouplingFieldDouble instances.
6482 * The mesh support of input parameter \a field is ignored here, it can be NULL.
6483 * The support of field \a field is expected to be those computed with the input parameter \a mesh, \a meshDimRelToMax,
6486 * This method will check that the field based on the computed support is coherent. If not an exception will be thrown.
6487 * A new profile is added only if no equal profile is missing.
6488 * For more info, see \ref AdvMEDLoaderAPIFieldRW
6489 * \param [in] field - the field to add to \a this. The field double values and mesh support are ignored.
6490 * \param [in] arrOfVals - the values of the field \a field used.
6491 * \param [in] mesh - the supporting mesh of \a field.
6492 * \param [in] meshDimRelToMax - a relative dimension of mesh entities \a field lies on (useless if field spatial discretization is ON_NODES).
6493 * \param [in] profile - ids of mesh entities on which corresponding field values lie.
6494 * \throw If either \a field or \a mesh or \a profile has an empty name.
6495 * \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
6496 * \throw If the data array of \a field is not set.
6497 * \throw If the data array of \a this is already allocated but has different number of
6498 * components than \a field.
6499 * \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
6500 * \sa setFieldNoProfileSBT()
6502 void MEDFileIntField1TS::setFieldProfile(const MEDCouplingFieldDouble *field, const DataArrayInt *arrOfVals, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile)
6505 contentNotNull()->setFieldProfile(field,arrOfVals,mesh,meshDimRelToMax,profile,*this,*contentNotNull());
6508 const MEDFileIntField1TSWithoutSDA *MEDFileIntField1TS::contentNotNull() const
6510 const MEDFileAnyTypeField1TSWithoutSDA *pt(_content);
6512 throw INTERP_KERNEL::Exception("MEDFileIntField1TS::contentNotNull : the content pointer is null !");
6513 const MEDFileIntField1TSWithoutSDA *ret=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(pt);
6515 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 !");
6519 MEDCouplingFieldDouble *MEDFileIntField1TS::getFieldAtLevel(TypeOfField type, int meshDimRelToMax, DataArrayInt* &arrOut, int renumPol) const
6521 if(getFileName().empty())
6522 throw INTERP_KERNEL::Exception("MEDFileIntField1TS::getFieldAtLevel : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtLevel method instead !");
6523 MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut2;
6524 MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldAtLevel(type,meshDimRelToMax,std::string(),renumPol,this,arrOut2,*contentNotNull());
6525 DataArrayInt *arrOutC=dynamic_cast<DataArrayInt *>((DataArray *)arrOut2);
6527 throw INTERP_KERNEL::Exception("MEDFileIntField1TS::getFieldAtLevelOld : mismatch between dataArrays type and MEDFileIntField1TS ! Expected int32 !");
6532 DataArrayInt *MEDFileIntField1TS::ReturnSafelyDataArrayInt(MEDCouplingAutoRefCountObjectPtr<DataArray>& arr)
6534 if(!((DataArray *)arr))
6535 throw INTERP_KERNEL::Exception("MEDFileIntField1TS::ReturnSafelyDataArrayInt : input DataArray is NULL !");
6536 DataArrayInt *arrC=dynamic_cast<DataArrayInt *>((DataArray *)arr);
6538 throw INTERP_KERNEL::Exception("MEDFileIntField1TS::ReturnSafelyDataArrayInt : input DataArray is not of type INT32 !");
6544 * Returns a new MEDCouplingFieldDouble of a given type lying on
6545 * the top level cells of the first mesh in MED file. If \a this field
6546 * has not been constructed via file reading, an exception is thrown.
6547 * For more info, see \ref AdvMEDLoaderAPIFieldRW
6548 * \param [in] type - a spatial discretization of interest.
6549 * \param [out] arrOut - the DataArrayInt containing values of field.
6550 * \param [in] renumPol - specifies how to permute values of the result field according to
6551 * the optional numbers of cells and nodes, if any. The valid values are
6552 * - 0 - do not permute.
6553 * - 1 - permute cells.
6554 * - 2 - permute nodes.
6555 * - 3 - permute cells and nodes.
6557 * \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6558 * caller is to delete this field using decrRef() as it is no more needed.
6559 * \throw If \a this field has not been constructed via file reading.
6560 * \throw If the MED file is not readable.
6561 * \throw If there is no mesh in the MED file.
6562 * \throw If no field values of the given \a type.
6563 * \throw If no field values lying on the top level support.
6564 * \sa getFieldAtLevel()
6566 MEDCouplingFieldDouble *MEDFileIntField1TS::getFieldAtTopLevel(TypeOfField type, DataArrayInt* &arrOut, int renumPol) const
6568 if(getFileName().empty())
6569 throw INTERP_KERNEL::Exception("MEDFileField1TS::getFieldAtTopLevel : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtTopLevel method instead !");
6570 MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
6571 MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldAtTopLevel(type,std::string(),renumPol,this,arr,*contentNotNull());
6572 arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
6577 * Returns a new MEDCouplingFieldDouble of given type lying on a given mesh.
6578 * For more info, see \ref AdvMEDLoaderAPIFieldRW
6579 * \param [in] type - a spatial discretization of the new field.
6580 * \param [in] mesh - the supporting mesh.
6581 * \param [out] arrOut - the DataArrayInt containing values of field.
6582 * \param [in] renumPol - specifies how to permute values of the result field according to
6583 * the optional numbers of cells and nodes, if any. The valid values are
6584 * - 0 - do not permute.
6585 * - 1 - permute cells.
6586 * - 2 - permute nodes.
6587 * - 3 - permute cells and nodes.
6589 * \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6590 * caller is to delete this field using decrRef() as it is no more needed.
6591 * \throw If no field of \a this is lying on \a mesh.
6592 * \throw If the mesh is empty.
6593 * \throw If no field values of the given \a type are available.
6594 * \sa getFieldAtLevel()
6595 * \sa getFieldOnMeshAtLevel()
6597 MEDCouplingFieldDouble *MEDFileIntField1TS::getFieldOnMeshAtLevel(TypeOfField type, const MEDCouplingMesh *mesh, DataArrayInt* &arrOut, int renumPol) const
6599 MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
6600 MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldOnMeshAtLevel(type,renumPol,this,mesh,0,0,arr,*contentNotNull());
6601 arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
6606 * Returns a new MEDCouplingFieldDouble of a given type lying on a given support.
6607 * For more info, see \ref AdvMEDLoaderAPIFieldRW
6608 * \param [in] type - a spatial discretization of interest.
6609 * \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6610 * \param [out] arrOut - the DataArrayInt containing values of field.
6611 * \param [in] mesh - the supporting mesh.
6612 * \param [in] renumPol - specifies how to permute values of the result field according to
6613 * the optional numbers of cells and nodes, if any. The valid values are
6614 * - 0 - do not permute.
6615 * - 1 - permute cells.
6616 * - 2 - permute nodes.
6617 * - 3 - permute cells and nodes.
6619 * \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6620 * caller is to delete this field using decrRef() as it is no more needed.
6621 * \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
6622 * \throw If no field of \a this is lying on \a mesh.
6623 * \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6624 * \sa getFieldAtLevel()
6625 * \sa getFieldOnMeshAtLevel()
6627 MEDCouplingFieldDouble *MEDFileIntField1TS::getFieldOnMeshAtLevel(TypeOfField type, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt* &arrOut, int renumPol) const
6629 MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
6630 MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,this,mesh,arr,*contentNotNull());
6631 arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
6636 * Returns a new MEDCouplingFieldDouble of a given type lying on a given support.
6637 * This method is called "Old" because in MED3 norm a field has only one meshName
6638 * attached, so this method is for readers of MED2 files. If \a this field
6639 * has not been constructed via file reading, an exception is thrown.
6640 * For more info, see \ref AdvMEDLoaderAPIFieldRW
6641 * \param [in] type - a spatial discretization of interest.
6642 * \param [in] mName - a name of the supporting mesh.
6643 * \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6644 * \param [out] arrOut - the DataArrayInt containing values of field.
6645 * \param [in] renumPol - specifies how to permute values of the result field according to
6646 * the optional numbers of cells and nodes, if any. The valid values are
6647 * - 0 - do not permute.
6648 * - 1 - permute cells.
6649 * - 2 - permute nodes.
6650 * - 3 - permute cells and nodes.
6652 * \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
6653 * caller is to delete this field using decrRef() as it is no more needed.
6654 * \throw If the MED file is not readable.
6655 * \throw If there is no mesh named \a mName in the MED file.
6656 * \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
6657 * \throw If \a this field has not been constructed via file reading.
6658 * \throw If no field of \a this is lying on the mesh named \a mName.
6659 * \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6660 * \sa getFieldAtLevel()
6662 MEDCouplingFieldDouble *MEDFileIntField1TS::getFieldAtLevelOld(TypeOfField type, const std::string& mname, int meshDimRelToMax, DataArrayInt* &arrOut, int renumPol) const
6664 if(getFileName().empty())
6665 throw INTERP_KERNEL::Exception("MEDFileField1TS::getFieldAtLevelOld : Request for a method that can be used for instances coming from file loading ! Use getFieldOnMeshAtLevel method instead !");
6666 MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
6667 MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=contentNotNull()->getFieldAtLevel(type,meshDimRelToMax,mname,renumPol,this,arr,*contentNotNull());
6668 arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
6673 * Returns values and a profile of the field of a given type lying on a given support.
6674 * For more info, see \ref AdvMEDLoaderAPIFieldRW
6675 * \param [in] type - a spatial discretization of the field.
6676 * \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
6677 * \param [in] mesh - the supporting mesh.
6678 * \param [out] pfl - a new instance of DataArrayInt holding ids of mesh entities the
6679 * field of interest lies on. If the field lies on all entities of the given
6680 * dimension, all ids in \a pfl are zero. The caller is to delete this array
6681 * using decrRef() as it is no more needed.
6682 * \return DataArrayInt * - a new instance of DataArrayInt holding values of the
6683 * field. The caller is to delete this array using decrRef() as it is no more needed.
6684 * \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
6685 * \throw If no field of \a this is lying on \a mesh.
6686 * \throw If no field values of the given \a type or given \a meshDimRelToMax are available.
6688 DataArrayInt *MEDFileIntField1TS::getFieldWithProfile(TypeOfField type, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt *&pfl) const
6690 MEDCouplingAutoRefCountObjectPtr<DataArray> arr=contentNotNull()->getFieldWithProfile(type,meshDimRelToMax,mesh,pfl,this,*contentNotNull());
6691 return MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
6694 MEDFileIntField1TSWithoutSDA *MEDFileIntField1TS::contentNotNull()
6696 MEDFileAnyTypeField1TSWithoutSDA *pt(_content);
6698 throw INTERP_KERNEL::Exception("MEDFileIntField1TS::contentNotNull : the non const content pointer is null !");
6699 MEDFileIntField1TSWithoutSDA *ret=dynamic_cast<MEDFileIntField1TSWithoutSDA *>(pt);
6701 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 !");
6705 DataArrayInt *MEDFileIntField1TS::getUndergroundDataArray() const
6707 return contentNotNull()->getUndergroundDataArrayInt();
6710 //= MEDFileAnyTypeFieldMultiTSWithoutSDA
6712 MEDFileAnyTypeFieldMultiTSWithoutSDA::MEDFileAnyTypeFieldMultiTSWithoutSDA()
6716 MEDFileAnyTypeFieldMultiTSWithoutSDA::MEDFileAnyTypeFieldMultiTSWithoutSDA(const std::string& fieldName):MEDFileFieldNameScope(fieldName)
6721 * \param [in] fieldId field id in C mode
6723 MEDFileAnyTypeFieldMultiTSWithoutSDA::MEDFileAnyTypeFieldMultiTSWithoutSDA(med_idt fid, int fieldId, bool loadAll)
6725 med_field_type typcha;
6726 std::string dtunitOut;
6727 int nbOfStep=MEDFileAnyTypeField1TS::LocateField2(fid,"",fieldId,false,_name,typcha,_infos,dtunitOut);
6728 setDtUnit(dtunitOut.c_str());
6729 loadStructureOrStructureAndBigArraysRecursively(fid,nbOfStep,typcha,loadAll);
6732 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)
6733 try:MEDFileFieldNameScope(fieldName),_infos(infos)
6735 setDtUnit(dtunit.c_str());
6736 loadStructureOrStructureAndBigArraysRecursively(fid,nbOfStep,fieldTyp,loadAll);
6738 catch(INTERP_KERNEL::Exception& e)
6743 std::size_t MEDFileAnyTypeFieldMultiTSWithoutSDA::getHeapMemorySizeWithoutChildren() const
6745 std::size_t ret(_name.capacity()+_infos.capacity()*sizeof(std::string)+_time_steps.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSWithoutSDA>));
6746 for(std::vector<std::string>::const_iterator it=_infos.begin();it!=_infos.end();it++)
6747 ret+=(*it).capacity();
6751 std::vector<const BigMemoryObject *> MEDFileAnyTypeFieldMultiTSWithoutSDA::getDirectChildren() const
6753 std::vector<const BigMemoryObject *> ret;
6754 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
6756 const MEDFileAnyTypeField1TSWithoutSDA *cur(*it);
6764 * 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
6767 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::buildFromTimeStepIds(const int *startIds, const int *endIds) const
6769 MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> ret=createNew();
6770 ret->setInfo(_infos);
6771 int sz=(int)_time_steps.size();
6772 for(const int *id=startIds;id!=endIds;id++)
6774 if(*id>=0 && *id<sz)
6776 const MEDFileAnyTypeField1TSWithoutSDA *tse=_time_steps[*id];
6777 MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> tse2;
6781 tse2=(const_cast<MEDFileAnyTypeField1TSWithoutSDA *>(tse));
6783 ret->pushBackTimeStep(tse2);
6787 std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::buildFromTimeStepIds : At pos #" << std::distance(startIds,id) << " value is " << *id;
6788 oss << " ! Should be in [0," << sz << ") !";
6789 throw INTERP_KERNEL::Exception(oss.str().c_str());
6792 if(ret->getNumberOfTS()>0)
6793 ret->synchronizeNameScope();
6794 ret->copyNameScope(*this);
6799 * 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
6802 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::buildFromTimeStepIds2(int bg, int end, int step) const
6804 static const char msg[]="MEDFileAnyTypeFieldMultiTSWithoutSDA::buildFromTimeStepIds2";
6805 int nbOfEntriesToKeep=DataArrayInt::GetNumberOfItemGivenBESRelative(bg,end,step,msg);
6806 MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> ret=createNew();
6807 ret->setInfo(_infos);
6808 int sz=(int)_time_steps.size();
6810 for(int i=0;i<nbOfEntriesToKeep;i++,j+=step)
6814 const MEDFileAnyTypeField1TSWithoutSDA *tse=_time_steps[j];
6815 MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> tse2;
6819 tse2=(const_cast<MEDFileAnyTypeField1TSWithoutSDA *>(tse));
6821 ret->pushBackTimeStep(tse2);
6825 std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::buildFromTimeStepIds : At pos #" << i << " value is " << j;
6826 oss << " ! Should be in [0," << sz << ") !";
6827 throw INTERP_KERNEL::Exception(oss.str().c_str());
6830 if(ret->getNumberOfTS()>0)
6831 ret->synchronizeNameScope();
6832 ret->copyNameScope(*this);
6836 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::partOfThisLyingOnSpecifiedTimeSteps(const std::vector< std::pair<int,int> >& timeSteps) const
6839 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ids=DataArrayInt::New(); ids->alloc(0,1);
6840 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,id++)
6842 const MEDFileAnyTypeField1TSWithoutSDA *cur(*it);
6845 std::pair<int,int> p(cur->getIteration(),cur->getOrder());
6846 if(std::find(timeSteps.begin(),timeSteps.end(),p)!=timeSteps.end())
6847 ids->pushBackSilent(id);
6849 return buildFromTimeStepIds(ids->begin(),ids->end());
6852 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::partOfThisNotLyingOnSpecifiedTimeSteps(const std::vector< std::pair<int,int> >& timeSteps) const
6855 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ids=DataArrayInt::New(); ids->alloc(0,1);
6856 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,id++)
6858 const MEDFileAnyTypeField1TSWithoutSDA *cur(*it);
6861 std::pair<int,int> p(cur->getIteration(),cur->getOrder());
6862 if(std::find(timeSteps.begin(),timeSteps.end(),p)==timeSteps.end())
6863 ids->pushBackSilent(id);
6865 return buildFromTimeStepIds(ids->begin(),ids->end());
6868 const std::vector<std::string>& MEDFileAnyTypeFieldMultiTSWithoutSDA::getInfo() const
6873 void MEDFileAnyTypeFieldMultiTSWithoutSDA::setInfo(const std::vector<std::string>& info)
6878 int MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepPos(int iteration, int order) const
6881 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,ret++)
6883 const MEDFileAnyTypeField1TSWithoutSDA *pt(*it);
6884 if(pt->isDealingTS(iteration,order))
6887 std::ostringstream oss; oss << "MEDFileFieldMultiTS::getTimeStepPos : Muli timestep field on time (" << iteration << "," << order << ") does not exist ! Available (iteration,order) are :\n";
6888 std::vector< std::pair<int,int> > vp=getIterations();
6889 for(std::vector< std::pair<int,int> >::const_iterator it2=vp.begin();it2!=vp.end();it2++)
6890 oss << "(" << (*it2).first << "," << (*it2).second << ") ";
6891 throw INTERP_KERNEL::Exception(oss.str().c_str());
6894 const MEDFileAnyTypeField1TSWithoutSDA& MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepEntry(int iteration, int order) const
6896 return *_time_steps[getTimeStepPos(iteration,order)];
6899 MEDFileAnyTypeField1TSWithoutSDA& MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepEntry(int iteration, int order)
6901 return *_time_steps[getTimeStepPos(iteration,order)];
6904 std::string MEDFileAnyTypeFieldMultiTSWithoutSDA::getMeshName() const
6906 if(_time_steps.empty())
6907 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::getMeshName : not time steps !");
6908 return _time_steps[0]->getMeshName();
6911 void MEDFileAnyTypeFieldMultiTSWithoutSDA::setMeshName(const std::string& newMeshName)
6913 std::string oldName(getMeshName());
6914 std::vector< std::pair<std::string,std::string> > v(1);
6915 v[0].first=oldName; v[0].second=newMeshName;
6919 bool MEDFileAnyTypeFieldMultiTSWithoutSDA::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab)
6922 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
6924 MEDFileAnyTypeField1TSWithoutSDA *cur(*it);
6926 ret=cur->changeMeshNames(modifTab) || ret;
6932 * See doc at MEDFileField1TSWithoutSDA::getUndergroundDataArray
6934 DataArray *MEDFileAnyTypeFieldMultiTSWithoutSDA::getUndergroundDataArray(int iteration, int order) const
6936 return getTimeStepEntry(iteration,order).getUndergroundDataArray();
6940 * See doc at MEDFileField1TSWithoutSDA::getUndergroundDataArrayExt
6942 DataArray *MEDFileAnyTypeFieldMultiTSWithoutSDA::getUndergroundDataArrayExt(int iteration, int order, std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
6944 return getTimeStepEntry(iteration,order).getUndergroundDataArrayExt(entries);
6947 bool MEDFileAnyTypeFieldMultiTSWithoutSDA::renumberEntitiesLyingOnMesh(const std::string& meshName, const std::vector<int>& oldCode, const std::vector<int>& newCode, const DataArrayInt *renumO2N,
6948 MEDFileFieldGlobsReal& glob)
6951 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
6953 MEDFileAnyTypeField1TSWithoutSDA *f1ts(*it);
6955 ret=f1ts->renumberEntitiesLyingOnMesh(meshName,oldCode,newCode,renumO2N,glob) || ret;
6960 void MEDFileAnyTypeFieldMultiTSWithoutSDA::simpleRepr(int bkOffset, std::ostream& oss, int fmtsId) const
6962 std::string startLine(bkOffset,' ');
6963 oss << startLine << "Field multi time steps [Type=" << getTypeStr() << "]";
6965 oss << " (" << fmtsId << ")";
6966 oss << " has the following name: \"" << _name << "\"." << std::endl;
6967 oss << startLine << "Field multi time steps has " << _infos.size() << " components with the following infos :" << std::endl;
6968 for(std::vector<std::string>::const_iterator it=_infos.begin();it!=_infos.end();it++)
6970 oss << startLine << " - \"" << *it << "\"" << std::endl;
6973 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,i++)
6975 std::string chapter(17,'0'+i);
6976 oss << startLine << chapter << std::endl;
6977 const MEDFileAnyTypeField1TSWithoutSDA *cur=(*it);
6979 cur->simpleRepr(bkOffset+2,oss,i);
6981 oss << startLine << " Field on one time step #" << i << " is not defined !" << std::endl;
6982 oss << startLine << chapter << std::endl;
6986 std::vector< std::pair<int,int> > MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeSteps(std::vector<double>& ret1) const
6988 std::size_t sz=_time_steps.size();
6989 std::vector< std::pair<int,int> > ret(sz);
6991 for(std::size_t i=0;i<sz;i++)
6993 const MEDFileAnyTypeField1TSWithoutSDA *f1ts=_time_steps[i];
6996 ret1[i]=f1ts->getTime(ret[i].first,ret[i].second);
7000 std::ostringstream oss; oss << "MEDFileFieldMultiTSWithoutSDA::getTimeSteps : At rank #" << i << " time step is not defined. Invoke eraseEmptyTS method !";
7001 throw INTERP_KERNEL::Exception(oss.str().c_str());
7007 void MEDFileAnyTypeFieldMultiTSWithoutSDA::pushBackTimeStep(MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA>& tse)
7009 MEDFileAnyTypeField1TSWithoutSDA *tse2(tse);
7011 throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::pushBackTimeStep : input content object is null !");
7012 checkCoherencyOfType(tse2);
7013 if(_time_steps.empty())
7015 setName(tse2->getName().c_str());
7016 setInfo(tse2->getInfo());
7018 checkThatComponentsMatch(tse2->getInfo());
7019 _time_steps.push_back(tse);
7022 void MEDFileAnyTypeFieldMultiTSWithoutSDA::synchronizeNameScope()
7024 std::size_t nbOfCompo=_infos.size();
7025 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7027 MEDFileAnyTypeField1TSWithoutSDA *cur=(*it);
7030 if((cur->getInfo()).size()!=nbOfCompo)
7032 std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::synchronizeNameScope : Mismatch in the number of components of parts ! Should be " << nbOfCompo;
7033 oss << " ! but the field at iteration=" << cur->getIteration() << " order=" << cur->getOrder() << " has " << (cur->getInfo()).size() << " components !";
7034 throw INTERP_KERNEL::Exception(oss.str().c_str());
7036 cur->copyNameScope(*this);
7041 void MEDFileAnyTypeFieldMultiTSWithoutSDA::loadStructureOrStructureAndBigArraysRecursively(med_idt fid, int nbPdt, med_field_type fieldTyp, bool loadAll)
7043 _time_steps.resize(nbPdt);
7044 for(int i=0;i<nbPdt;i++)
7046 std::vector< std::pair<int,int> > ts;
7047 med_int numdt=0,numo=0;
7048 med_int meshIt=0,meshOrder=0;
7050 MEDfieldComputingStepMeshInfo(fid,_name.c_str(),i+1,&numdt,&numo,&dt,&meshIt,&meshOrder);
7055 _time_steps[i]=MEDFileField1TSWithoutSDA::New(_name.c_str(),i+1,numdt,numo,_infos);
7060 _time_steps[i]=MEDFileIntField1TSWithoutSDA::New(_name.c_str(),i+1,numdt,numo,_infos);
7064 throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::loadStructureOrStructureAndBigArraysRecursively : managed field type are : FLOAT64, INT32 !");
7067 _time_steps[i]->loadStructureAndBigArraysRecursively(fid,*this);
7069 _time_steps[i]->loadOnlyStructureOfDataRecursively(fid,*this);
7073 void MEDFileAnyTypeFieldMultiTSWithoutSDA::writeLL(med_idt fid, const MEDFileWritable& opts) const
7075 if(_time_steps.empty())
7076 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::writeLL : no time steps set !");
7077 checkThatNbOfCompoOfTSMatchThis();
7078 std::vector<std::string> infos(getInfo());
7079 int nbComp=infos.size();
7080 INTERP_KERNEL::AutoPtr<char> comp=MEDLoaderBase::buildEmptyString(nbComp*MED_SNAME_SIZE);
7081 INTERP_KERNEL::AutoPtr<char> unit=MEDLoaderBase::buildEmptyString(nbComp*MED_SNAME_SIZE);
7082 for(int i=0;i<nbComp;i++)
7084 std::string info=infos[i];
7086 MEDLoaderBase::splitIntoNameAndUnit(info,c,u);
7087 MEDLoaderBase::safeStrCpy2(c.c_str(),MED_SNAME_SIZE,comp+i*MED_SNAME_SIZE,opts.getTooLongStrPolicy());
7088 MEDLoaderBase::safeStrCpy2(u.c_str(),MED_SNAME_SIZE,unit+i*MED_SNAME_SIZE,opts.getTooLongStrPolicy());
7091 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::write : MED file does not accept field with empty name !");
7092 MEDfieldCr(fid,_name.c_str(),getMEDFileFieldType(),nbComp,comp,unit,getDtUnit().c_str(),getMeshName().c_str());
7093 int nbOfTS=_time_steps.size();
7094 for(int i=0;i<nbOfTS;i++)
7095 _time_steps[i]->writeLL(fid,opts,*this);
7098 void MEDFileAnyTypeFieldMultiTSWithoutSDA::loadBigArraysRecursively(med_idt fid, const MEDFileFieldNameScope& nasc)
7100 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7102 MEDFileAnyTypeField1TSWithoutSDA *elt(*it);
7104 elt->loadBigArraysRecursively(fid,nasc);
7108 void MEDFileAnyTypeFieldMultiTSWithoutSDA::loadBigArraysRecursivelyIfNecessary(med_idt fid, const MEDFileFieldNameScope& nasc)
7110 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7112 MEDFileAnyTypeField1TSWithoutSDA *elt(*it);
7114 elt->loadBigArraysRecursivelyIfNecessary(fid,nasc);
7118 void MEDFileAnyTypeFieldMultiTSWithoutSDA::unloadArrays()
7120 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7122 MEDFileAnyTypeField1TSWithoutSDA *elt(*it);
7124 elt->unloadArrays();
7128 int MEDFileAnyTypeFieldMultiTSWithoutSDA::getNumberOfTS() const
7130 return _time_steps.size();
7133 void MEDFileAnyTypeFieldMultiTSWithoutSDA::eraseEmptyTS()
7135 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > newTS;
7136 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7138 const MEDFileAnyTypeField1TSWithoutSDA *tmp=(*it);
7140 newTS.push_back(*it);
7145 void MEDFileAnyTypeFieldMultiTSWithoutSDA::eraseTimeStepIds(const int *startIds, const int *endIds)
7147 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > newTS;
7148 int maxId=(int)_time_steps.size();
7150 std::set<int> idsToDel;
7151 for(const int *id=startIds;id!=endIds;id++,ii++)
7153 if(*id>=0 && *id<maxId)
7155 idsToDel.insert(*id);
7159 std::ostringstream oss; oss << "MEDFileFieldMultiTSWithoutSDA::eraseTimeStepIds : At pos #" << ii << " request for id=" << *id << " not in [0," << maxId << ") !";
7160 throw INTERP_KERNEL::Exception(oss.str().c_str());
7163 for(int iii=0;iii<maxId;iii++)
7164 if(idsToDel.find(iii)==idsToDel.end())
7165 newTS.push_back(_time_steps[iii]);
7169 void MEDFileAnyTypeFieldMultiTSWithoutSDA::eraseTimeStepIds2(int bg, int end, int step)
7171 static const char msg[]="MEDFileAnyTypeFieldMultiTSWithoutSDA::eraseTimeStepIds2";
7172 int nbOfEntriesToKill=DataArrayInt::GetNumberOfItemGivenBESRelative(bg,end,step,msg);
7173 if(nbOfEntriesToKill==0)
7175 std::size_t sz=_time_steps.size();
7176 std::vector<bool> b(sz,true);
7178 for(int i=0;i<nbOfEntriesToKill;i++,j+=step)
7180 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > newTS;
7181 for(std::size_t i=0;i<sz;i++)
7183 newTS.push_back(_time_steps[i]);
7187 int MEDFileAnyTypeFieldMultiTSWithoutSDA::getPosOfTimeStep(int iteration, int order) const
7190 std::ostringstream oss; oss << "MEDFileFieldMultiTSWithoutSDA::getPosOfTimeStep : No such time step (" << iteration << "," << order << ") !\nPossibilities are : ";
7191 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,ret++)
7193 const MEDFileAnyTypeField1TSWithoutSDA *tmp(*it);
7197 tmp->getTime(it2,ord);
7198 if(it2==iteration && order==ord)
7201 oss << "(" << it2 << "," << ord << "), ";
7204 throw INTERP_KERNEL::Exception(oss.str().c_str());
7207 int MEDFileAnyTypeFieldMultiTSWithoutSDA::getPosGivenTime(double time, double eps) const
7210 std::ostringstream oss; oss << "MEDFileFieldMultiTSWithoutSDA::getPosGivenTime : No such time step " << time << "! \nPossibilities are : ";
7212 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,ret++)
7214 const MEDFileAnyTypeField1TSWithoutSDA *tmp(*it);
7218 double ti=tmp->getTime(it2,ord);
7219 if(fabs(time-ti)<eps)
7225 throw INTERP_KERNEL::Exception(oss.str().c_str());
7228 std::vector< std::pair<int,int> > MEDFileAnyTypeFieldMultiTSWithoutSDA::getIterations() const
7230 int lgth=_time_steps.size();
7231 std::vector< std::pair<int,int> > ret(lgth);
7232 for(int i=0;i<lgth;i++)
7233 _time_steps[i]->fillIteration(ret[i]);
7238 * 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'
7239 * This method returns two things.
7240 * - The absolute dimension of 'this' in first parameter.
7241 * - The available ext levels relative to the absolute dimension returned in first parameter. These relative levels are relative
7242 * to the first output parameter. The values in 'levs' will be returned in decreasing order.
7244 * This method is designed for MEDFileFieldMultiTS instances that have a discritization ON_CELLS, ON_GAUSS_NE and ON_GAUSS.
7245 * Only these 3 discretizations will be taken into account here.
7247 * If 'this' is empty this method will throw an INTERP_KERNEL::Exception.
7248 * If there is \b only node fields defined in 'this' -1 is returned and 'levs' output parameter will be empty. In this
7249 * case the caller has to know the underlying mesh it refers to. By defaut it is the level 0 of the corresponding mesh.
7251 * This method is usefull to make the link between meshDimension of the underlying mesh in 'this' and the levels on 'this'.
7252 * 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'.
7254 * Let's consider the typical following case :
7255 * - a mesh 'm1' has a meshDimension 3 and has the following non empty levels
7256 * [0,-1,-2] for example 'm1' lies on TETRA4, HEXA8 TRI3 and SEG2
7257 * - 'f1' lies on 'm1' and is defined on 3D and 1D cells for example
7259 * - 'f2' lies on 'm1' too and is defined on 2D and 1D cells for example TRI3 and SEG2
7261 * In this case f1->getNonEmptyLevelsExt will return (3,[0,-2]) and f2->getNonEmptyLevelsExt will return (2,[0,-1])
7263 * To retrieve the highest level of f1 it should be done, f1->getFieldAtLevel(ON_CELLS,3-3+0);//absDim-meshDim+relativeLev
7264 * To retrieve the lowest level of f1 it should be done, f1->getFieldAtLevel(ON_CELLS,3-3+(-2));//absDim-meshDim+relativeLev
7265 * To retrieve the highest level of f2 it should be done, f1->getFieldAtLevel(ON_CELLS,2-3+0);//absDim-meshDim+relativeLev
7266 * To retrieve the lowest level of f2 it should be done, f1->getFieldAtLevel(ON_CELLS,2-3+(-1));//absDim-meshDim+relativeLev
7268 int MEDFileAnyTypeFieldMultiTSWithoutSDA::getNonEmptyLevels(int iteration, int order, const std::string& mname, std::vector<int>& levs) const
7270 return getTimeStepEntry(iteration,order).getNonEmptyLevels(mname,levs);
7273 const MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2(int pos) const
7275 if(pos<0 || pos>=(int)_time_steps.size())
7277 std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2 : request for pos #" << pos << " whereas should be in [0," << _time_steps.size() << ") !";
7278 throw INTERP_KERNEL::Exception(oss.str().c_str());
7280 const MEDFileAnyTypeField1TSWithoutSDA *item=_time_steps[pos];
7283 std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2 : request for pos #" << pos << ", this pos id exists but the underlying Field1TS is null !";
7284 oss << "\nTry to use following method eraseEmptyTS !";
7285 throw INTERP_KERNEL::Exception(oss.str().c_str());
7290 MEDFileAnyTypeField1TSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2(int pos)
7292 if(pos<0 || pos>=(int)_time_steps.size())
7294 std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2 : request for pos #" << pos << " whereas should be in [0," << _time_steps.size() << ") !";
7295 throw INTERP_KERNEL::Exception(oss.str().c_str());
7297 MEDFileAnyTypeField1TSWithoutSDA *item=_time_steps[pos];
7300 std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::getTimeStepAtPos2 : request for pos #" << pos << ", this pos id exists but the underlying Field1TS is null !";
7301 oss << "\nTry to use following method eraseEmptyTS !";
7302 throw INTERP_KERNEL::Exception(oss.str().c_str());
7307 std::vector<std::string> MEDFileAnyTypeFieldMultiTSWithoutSDA::getPflsReallyUsed2() const
7309 std::vector<std::string> ret;
7310 std::set<std::string> ret2;
7311 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TSWithoutSDA > >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7313 std::vector<std::string> tmp=(*it)->getPflsReallyUsed2();
7314 for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
7315 if(ret2.find(*it2)==ret2.end())
7317 ret.push_back(*it2);
7324 std::vector<std::string> MEDFileAnyTypeFieldMultiTSWithoutSDA::getLocsReallyUsed2() const
7326 std::vector<std::string> ret;
7327 std::set<std::string> ret2;
7328 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TSWithoutSDA > >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7330 std::vector<std::string> tmp=(*it)->getLocsReallyUsed2();
7331 for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
7332 if(ret2.find(*it2)==ret2.end())
7334 ret.push_back(*it2);
7341 std::vector<std::string> MEDFileAnyTypeFieldMultiTSWithoutSDA::getPflsReallyUsedMulti2() const
7343 std::vector<std::string> ret;
7344 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TSWithoutSDA > >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7346 std::vector<std::string> tmp=(*it)->getPflsReallyUsedMulti2();
7347 ret.insert(ret.end(),tmp.begin(),tmp.end());
7352 std::vector<std::string> MEDFileAnyTypeFieldMultiTSWithoutSDA::getLocsReallyUsedMulti2() const
7354 std::vector<std::string> ret;
7355 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TSWithoutSDA > >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7357 std::vector<std::string> tmp=(*it)->getLocsReallyUsedMulti2();
7358 ret.insert(ret.end(),tmp.begin(),tmp.end());
7363 void MEDFileAnyTypeFieldMultiTSWithoutSDA::changePflsRefsNamesGen2(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
7365 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TSWithoutSDA > >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7366 (*it)->changePflsRefsNamesGen2(mapOfModif);
7369 void MEDFileAnyTypeFieldMultiTSWithoutSDA::changeLocsRefsNamesGen2(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
7371 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeField1TSWithoutSDA > >::iterator it=_time_steps.begin();it!=_time_steps.end();it++)
7372 (*it)->changeLocsRefsNamesGen2(mapOfModif);
7375 std::vector< std::vector<TypeOfField> > MEDFileAnyTypeFieldMultiTSWithoutSDA::getTypesOfFieldAvailable() const
7377 int lgth=_time_steps.size();
7378 std::vector< std::vector<TypeOfField> > ret(lgth);
7379 for(int i=0;i<lgth;i++)
7380 _time_steps[i]->fillTypesOfFieldAvailable(ret[i]);
7385 * entry point for users that want to iterate into MEDFile DataStructure without any overhead.
7387 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
7389 return getTimeStepEntry(iteration,order).getFieldSplitedByType(mname,types,typesF,pfls,locs);
7392 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTSWithoutSDA::deepCpy() const
7394 MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> ret=shallowCpy();
7396 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,i++)
7398 if((const MEDFileAnyTypeField1TSWithoutSDA *)*it)
7399 ret->_time_steps[i]=(*it)->deepCpy();
7404 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > MEDFileAnyTypeFieldMultiTSWithoutSDA::splitComponents() const
7406 std::size_t sz(_infos.size()),sz2(_time_steps.size());
7407 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > ret(sz);
7408 std::vector< std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > > ts(sz2);
7409 for(std::size_t i=0;i<sz;i++)
7411 ret[i]=shallowCpy();
7412 ret[i]->_infos.resize(1); ret[i]->_infos[0]=_infos[i];
7414 for(std::size_t i=0;i<sz2;i++)
7416 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > ret1=_time_steps[i]->splitComponents();
7419 std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::splitComponents : At rank #" << i << " number of components is " << ret1.size() << " whereas it should be for all time steps " << sz << " !";
7420 throw INTERP_KERNEL::Exception(oss.str().c_str());
7424 for(std::size_t i=0;i<sz;i++)
7425 for(std::size_t j=0;j<sz2;j++)
7426 ret[i]->_time_steps[j]=ts[j][i];
7431 * This method splits into discretization each time steps in \a this.
7432 * ** WARNING ** the returned instances are not compulsary defined on the same time steps series !
7434 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > MEDFileAnyTypeFieldMultiTSWithoutSDA::splitDiscretizations() const
7436 std::size_t sz(_time_steps.size());
7437 std::vector< std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > > items(sz);
7438 for(std::size_t i=0;i<sz;i++)
7440 const MEDFileAnyTypeField1TSWithoutSDA *timeStep(_time_steps[i]);
7443 std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::splitDiscretizations : time step #" << i << " is null !";
7444 throw INTERP_KERNEL::Exception(oss.str().c_str());
7446 items[i]=timeStep->splitDiscretizations();
7449 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > ret;
7450 std::vector< std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > > ret2;
7451 std::vector< TypeOfField > types;
7452 for(std::vector< std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > >::const_iterator it0=items.begin();it0!=items.end();it0++)
7453 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++)
7455 std::vector<TypeOfField> ts=(*it1)->getTypesOfFieldAvailable();
7457 throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::splitDiscretizations : it appears that the splitting of MEDFileAnyTypeField1TSWithoutSDA::splitDiscretizations has returned invalid result !");
7458 std::vector< TypeOfField >::iterator it2=std::find(types.begin(),types.end(),ts[0]);
7459 if(it2==types.end())
7460 types.push_back(ts[0]);
7462 ret.resize(types.size()); ret2.resize(types.size());
7463 for(std::vector< std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> > >::const_iterator it0=items.begin();it0!=items.end();it0++)
7464 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it1=(*it0).begin();it1!=(*it0).end();it1++)
7466 TypeOfField typ=(*it1)->getTypesOfFieldAvailable()[0];
7467 std::size_t pos=std::distance(types.begin(),std::find(types.begin(),types.end(),typ));
7468 ret2[pos].push_back(*it1);
7470 for(std::size_t i=0;i<types.size();i++)
7472 MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> elt=createNew();
7473 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::iterator it1=ret2[i].begin();it1!=ret2[i].end();it1++)
7474 elt->pushBackTimeStep(*it1);//also updates infos in elt
7476 elt->MEDFileFieldNameScope::operator=(*this);
7481 void MEDFileAnyTypeFieldMultiTSWithoutSDA::copyTinyInfoFrom(const MEDCouplingFieldDouble *field, const DataArray *arr)
7483 _name=field->getName();
7485 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::copyTinyInfoFrom : unsupported fields with no name in MED file !");
7487 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::copyTinyInfoFrom : no array set !");
7488 _infos=arr->getInfoOnComponents();
7491 void MEDFileAnyTypeFieldMultiTSWithoutSDA::checkCoherencyOfTinyInfo(const MEDCouplingFieldDouble *field, const DataArray *arr) const
7493 static const char MSG[]="MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfTinyInfo : invalid ";
7494 if(_name!=field->getName())
7496 std::ostringstream oss; oss << MSG << "name ! should be \"" << _name;
7497 oss << "\" and it is set in input field to \"" << field->getName() << "\" !";
7498 throw INTERP_KERNEL::Exception(oss.str().c_str());
7501 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfTinyInfo : no array set !");
7502 checkThatComponentsMatch(arr->getInfoOnComponents());
7505 void MEDFileAnyTypeFieldMultiTSWithoutSDA::checkThatComponentsMatch(const std::vector<std::string>& compos) const
7507 static const char MSG[]="MEDFileFieldMultiTSWithoutSDA::checkThatComponentsMatch : ";
7508 if(getInfo().size()!=compos.size())
7510 std::ostringstream oss; oss << MSG << "mismatch of number of components between this (" << getInfo().size() << ") and ";
7511 oss << " number of components of element to append (" << compos.size() << ") !";
7512 throw INTERP_KERNEL::Exception(oss.str().c_str());
7516 std::ostringstream oss; oss << MSG << "components have same size but are different ! should be \"";
7517 std::copy(_infos.begin(),_infos.end(),std::ostream_iterator<std::string>(oss,", "));
7518 oss << " But compo in input fields are : ";
7519 std::copy(compos.begin(),compos.end(),std::ostream_iterator<std::string>(oss,", "));
7521 throw INTERP_KERNEL::Exception(oss.str().c_str());
7525 void MEDFileAnyTypeFieldMultiTSWithoutSDA::checkThatNbOfCompoOfTSMatchThis() const
7527 std::size_t sz=_infos.size();
7529 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,j++)
7531 const MEDFileAnyTypeField1TSWithoutSDA *elt(*it);
7533 if(elt->getInfo().size()!=sz)
7535 std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::checkThatNbOfCompoOfTSMatchThis : At pos #" << j << " the number of components is equal to ";
7536 oss << elt->getInfo().size() << " whereas it is expected to be equal to " << sz << " !";
7537 throw INTERP_KERNEL::Exception(oss.str().c_str());
7542 void MEDFileAnyTypeFieldMultiTSWithoutSDA::appendFieldNoProfileSBT(const MEDCouplingFieldDouble *field, const DataArray *arr, MEDFileFieldGlobsReal& glob)
7545 throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::appendFieldNoProfileSBT : input field is NULL !");
7546 if(!_time_steps.empty())
7547 checkCoherencyOfTinyInfo(field,arr);
7548 MEDFileAnyTypeField1TSWithoutSDA *objC=createNew1TSWithoutSDAEmptyInstance();
7549 MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> obj(objC);
7550 objC->setFieldNoProfileSBT(field,arr,glob,*this);
7551 copyTinyInfoFrom(field,arr);
7552 _time_steps.push_back(obj);
7555 void MEDFileAnyTypeFieldMultiTSWithoutSDA::appendFieldProfile(const MEDCouplingFieldDouble *field, const DataArray *arr, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile, MEDFileFieldGlobsReal& glob)
7558 throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTSWithoutSDA::appendFieldNoProfileSBT : input field is NULL !");
7559 if(!_time_steps.empty())
7560 checkCoherencyOfTinyInfo(field,arr);
7561 MEDFileField1TSWithoutSDA *objC=new MEDFileField1TSWithoutSDA;
7562 MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> obj(objC);
7563 objC->setFieldProfile(field,arr,mesh,meshDimRelToMax,profile,glob,*this);
7564 copyTinyInfoFrom(field,arr);
7565 _time_steps.push_back(obj);
7568 void MEDFileAnyTypeFieldMultiTSWithoutSDA::setIteration(int i, MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> ts)
7570 int sz=(int)_time_steps.size();
7573 std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::setIteration : trying to set element at place #" << i << " should be in [0," << sz << ") !";
7574 throw INTERP_KERNEL::Exception(oss.str().c_str());
7576 const MEDFileAnyTypeField1TSWithoutSDA *tsPtr(ts);
7579 if(tsPtr->getNumberOfComponents()!=(int)_infos.size())
7581 std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTSWithoutSDA::setIteration : trying to set element with " << tsPtr->getNumberOfComponents() << " components ! Should be " << _infos.size() << " !";
7582 throw INTERP_KERNEL::Exception(oss.str().c_str());
7588 //= MEDFileFieldMultiTSWithoutSDA
7590 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)
7592 return new MEDFileFieldMultiTSWithoutSDA(fid,fieldName,fieldTyp,infos,nbOfStep,dtunit,loadAll);
7595 MEDFileFieldMultiTSWithoutSDA::MEDFileFieldMultiTSWithoutSDA()
7599 MEDFileFieldMultiTSWithoutSDA::MEDFileFieldMultiTSWithoutSDA(const std::string& fieldName):MEDFileAnyTypeFieldMultiTSWithoutSDA(fieldName)
7604 * \param [in] fieldId field id in C mode
7606 MEDFileFieldMultiTSWithoutSDA::MEDFileFieldMultiTSWithoutSDA(med_idt fid, int fieldId, bool loadAll)
7607 try:MEDFileAnyTypeFieldMultiTSWithoutSDA(fid,fieldId,loadAll)
7610 catch(INTERP_KERNEL::Exception& e)
7613 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)
7614 try:MEDFileAnyTypeFieldMultiTSWithoutSDA(fid,fieldName,fieldTyp,infos,nbOfStep,dtunit,loadAll)
7617 catch(INTERP_KERNEL::Exception& e)
7620 MEDFileAnyTypeField1TSWithoutSDA *MEDFileFieldMultiTSWithoutSDA::createNew1TSWithoutSDAEmptyInstance() const
7622 return new MEDFileField1TSWithoutSDA;
7625 void MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfType(const MEDFileAnyTypeField1TSWithoutSDA *f1ts) const
7628 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfType : input field1TS is NULL ! Impossible to check !");
7629 const MEDFileField1TSWithoutSDA *f1tsC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(f1ts);
7631 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::checkCoherencyOfType : the input field1TS is not a FLOAT64 type !");
7634 const char *MEDFileFieldMultiTSWithoutSDA::getTypeStr() const
7636 return MEDFileField1TSWithoutSDA::TYPE_STR;
7639 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileFieldMultiTSWithoutSDA::shallowCpy() const
7641 return new MEDFileFieldMultiTSWithoutSDA(*this);
7644 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileFieldMultiTSWithoutSDA::createNew() const
7646 return new MEDFileFieldMultiTSWithoutSDA;
7650 * entry point for users that want to iterate into MEDFile DataStructure with a reduced overhead because output arrays are extracted (created) specially
7651 * for the call of this method. That's why the DataArrayDouble instance in returned vector of vector should be dealed by the caller.
7653 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
7655 const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=getTimeStepEntry(iteration,order);
7656 const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
7658 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::getFieldSplitedByType2 : mismatch of type of field expecting FLOAT64 !");
7659 return myF1TSC->getFieldSplitedByType2(mname,types,typesF,pfls,locs);
7662 MEDFileIntFieldMultiTSWithoutSDA *MEDFileFieldMultiTSWithoutSDA::convertToInt() const
7664 MEDCouplingAutoRefCountObjectPtr<MEDFileIntFieldMultiTSWithoutSDA> ret(new MEDFileIntFieldMultiTSWithoutSDA);
7665 ret->MEDFileAnyTypeFieldMultiTSWithoutSDA::operator =(*this);
7667 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,i++)
7669 const MEDFileAnyTypeField1TSWithoutSDA *eltToConv(*it);
7672 const MEDFileField1TSWithoutSDA *eltToConvC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(eltToConv);
7674 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTSWithoutSDA::convertToInt : presence of an invalid 1TS type ! Should be of type FLOAT64 !");
7675 MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> elt=eltToConvC->convertToInt();
7676 ret->setIteration(i,elt);
7682 //= MEDFileAnyTypeFieldMultiTS
7684 MEDFileAnyTypeFieldMultiTS::MEDFileAnyTypeFieldMultiTS()
7688 MEDFileAnyTypeFieldMultiTS::MEDFileAnyTypeFieldMultiTS(const std::string& fileName, bool loadAll)
7689 try:MEDFileFieldGlobsReal(fileName)
7691 MEDFileUtilities::CheckFileForRead(fileName);
7692 MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
7693 _content=BuildContentFrom(fid,fileName,loadAll);
7696 catch(INTERP_KERNEL::Exception& e)
7701 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTS::BuildContentFrom(med_idt fid, const std::string& fileName, const std::string& fieldName, bool loadAll)
7703 med_field_type typcha;
7704 std::vector<std::string> infos;
7707 MEDFileAnyTypeField1TS::LocateField(fid,fileName,fieldName,i,typcha,infos,dtunit);
7708 MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> ret;
7713 ret=new MEDFileFieldMultiTSWithoutSDA(fid,i,loadAll);
7718 ret=new MEDFileIntFieldMultiTSWithoutSDA(fid,i,loadAll);
7723 std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTS::BuildContentFrom(fileName,fieldName) : file \'" << fileName << "\' contains field with name \'" << fieldName << "\' but the type of field is not in [MED_FLOAT64, MED_INT32] !";
7724 throw INTERP_KERNEL::Exception(oss.str().c_str());
7727 ret->setDtUnit(dtunit.c_str());
7731 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTS::BuildContentFrom(med_idt fid, const std::string& fileName, bool loadAll)
7733 med_field_type typcha;
7735 std::vector<std::string> infos;
7736 std::string dtunit,fieldName;
7737 MEDFileAnyTypeField1TS::LocateField2(fid,fileName,0,true,fieldName,typcha,infos,dtunit);
7738 MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> ret;
7743 ret=new MEDFileFieldMultiTSWithoutSDA(fid,0,loadAll);
7748 ret=new MEDFileIntFieldMultiTSWithoutSDA(fid,0,loadAll);
7753 std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTS::BuildContentFrom(fileName) : file \'" << fileName << "\' contains field with name \'" << fieldName << "\' but the type of the first field is not in [MED_FLOAT64, MED_INT32] !";
7754 throw INTERP_KERNEL::Exception(oss.str().c_str());
7757 ret->setDtUnit(dtunit.c_str());
7761 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent(MEDFileAnyTypeFieldMultiTSWithoutSDA *c, const std::string& fileName)
7764 throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent : empty content in input : unable to build a new instance !");
7765 if(dynamic_cast<const MEDFileFieldMultiTSWithoutSDA *>(c))
7767 MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTS> ret=MEDFileFieldMultiTS::New();
7768 ret->setFileName(fileName);
7769 ret->_content=c; c->incrRef();
7772 if(dynamic_cast<const MEDFileIntFieldMultiTSWithoutSDA *>(c))
7774 MEDCouplingAutoRefCountObjectPtr<MEDFileIntFieldMultiTS> ret=MEDFileIntFieldMultiTS::New();
7775 ret->setFileName(fileName);
7776 ret->_content=c; c->incrRef();
7779 throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent : internal error ! a content of type different from FLOAT64 and INT32 has been built but not intercepted !");
7782 MEDFileAnyTypeFieldMultiTS::MEDFileAnyTypeFieldMultiTS(const std::string& fileName, const std::string& fieldName, bool loadAll)
7783 try:MEDFileFieldGlobsReal(fileName)
7785 MEDFileUtilities::CheckFileForRead(fileName);
7786 MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
7787 _content=BuildContentFrom(fid,fileName,fieldName,loadAll);
7790 catch(INTERP_KERNEL::Exception& e)
7795 //= MEDFileIntFieldMultiTSWithoutSDA
7797 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)
7799 return new MEDFileIntFieldMultiTSWithoutSDA(fid,fieldName,fieldTyp,infos,nbOfStep,dtunit,loadAll);
7802 MEDFileIntFieldMultiTSWithoutSDA::MEDFileIntFieldMultiTSWithoutSDA()
7806 MEDFileIntFieldMultiTSWithoutSDA::MEDFileIntFieldMultiTSWithoutSDA(const std::string& fieldName):MEDFileAnyTypeFieldMultiTSWithoutSDA(fieldName)
7810 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)
7811 try:MEDFileAnyTypeFieldMultiTSWithoutSDA(fid,fieldName,fieldTyp,infos,nbOfStep,dtunit,loadAll)
7814 catch(INTERP_KERNEL::Exception& e)
7818 * \param [in] fieldId field id in C mode
7820 MEDFileIntFieldMultiTSWithoutSDA::MEDFileIntFieldMultiTSWithoutSDA(med_idt fid, int fieldId, bool loadAll)
7821 try:MEDFileAnyTypeFieldMultiTSWithoutSDA(fid,fieldId,loadAll)
7824 catch(INTERP_KERNEL::Exception& e)
7827 MEDFileAnyTypeField1TSWithoutSDA *MEDFileIntFieldMultiTSWithoutSDA::createNew1TSWithoutSDAEmptyInstance() const
7829 return new MEDFileIntField1TSWithoutSDA;
7832 void MEDFileIntFieldMultiTSWithoutSDA::checkCoherencyOfType(const MEDFileAnyTypeField1TSWithoutSDA *f1ts) const
7835 throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTSWithoutSDA::checkCoherencyOfType : input field1TS is NULL ! Impossible to check !");
7836 const MEDFileIntField1TSWithoutSDA *f1tsC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(f1ts);
7838 throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTSWithoutSDA::checkCoherencyOfType : the input field1TS is not a INT32 type !");
7841 const char *MEDFileIntFieldMultiTSWithoutSDA::getTypeStr() const
7843 return MEDFileIntField1TSWithoutSDA::TYPE_STR;
7846 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTSWithoutSDA::shallowCpy() const
7848 return new MEDFileIntFieldMultiTSWithoutSDA(*this);
7851 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTSWithoutSDA::createNew() const
7853 return new MEDFileIntFieldMultiTSWithoutSDA;
7856 MEDFileFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTSWithoutSDA::convertToDouble() const
7858 MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTSWithoutSDA> ret(new MEDFileFieldMultiTSWithoutSDA);
7859 ret->MEDFileAnyTypeFieldMultiTSWithoutSDA::operator =(*this);
7861 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> >::const_iterator it=_time_steps.begin();it!=_time_steps.end();it++,i++)
7863 const MEDFileAnyTypeField1TSWithoutSDA *eltToConv(*it);
7866 const MEDFileIntField1TSWithoutSDA *eltToConvC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(eltToConv);
7868 throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTSWithoutSDA::convertToInt : presence of an invalid 1TS type ! Should be of type INT32 !");
7869 MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> elt=eltToConvC->convertToDouble();
7870 ret->setIteration(i,elt);
7876 //= MEDFileAnyTypeFieldMultiTS
7879 * Returns a new instance of MEDFileFieldMultiTS or MEDFileIntFieldMultiTS holding data of the first field
7880 * that has been read from a specified MED file.
7881 * \param [in] fileName - the name of the MED file to read.
7882 * \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS or MEDFileIntFieldMultiTS. The caller
7883 * is to delete this field using decrRef() as it is no more needed.
7884 * \throw If reading the file fails.
7886 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::New(const std::string& fileName, bool loadAll)
7888 MEDFileUtilities::CheckFileForRead(fileName);
7889 MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
7890 MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> c=BuildContentFrom(fid,fileName,loadAll);
7891 MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> ret=BuildNewInstanceFromContent(c,fileName);
7892 ret->loadGlobals(fid);
7897 * Returns a new instance of MEDFileFieldMultiTS or MEDFileIntFieldMultiTS holding data of a given field
7898 * that has been read from a specified MED file.
7899 * \param [in] fileName - the name of the MED file to read.
7900 * \param [in] fieldName - the name of the field to read.
7901 * \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS or MEDFileIntFieldMultiTS. The caller
7902 * is to delete this field using decrRef() as it is no more needed.
7903 * \throw If reading the file fails.
7904 * \throw If there is no field named \a fieldName in the file.
7906 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::New(const std::string& fileName, const std::string& fieldName, bool loadAll)
7908 MEDFileUtilities::CheckFileForRead(fileName);
7909 MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
7910 MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> c=BuildContentFrom(fid,fileName,fieldName,loadAll);
7911 MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> ret=BuildNewInstanceFromContent(c,fileName);
7912 ret->loadGlobals(fid);
7917 * This constructor is a shallow copy constructor. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
7918 * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
7920 * \warning this is a shallow copy constructor
7922 MEDFileAnyTypeFieldMultiTS::MEDFileAnyTypeFieldMultiTS(const MEDFileAnyTypeFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent)
7924 if(!shallowCopyOfContent)
7926 const MEDFileAnyTypeFieldMultiTSWithoutSDA *otherPtr(&other);
7927 otherPtr->incrRef();
7928 _content=const_cast<MEDFileAnyTypeFieldMultiTSWithoutSDA *>(otherPtr);
7932 _content=other.shallowCpy();
7936 MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTS::contentNotNullBase()
7938 MEDFileAnyTypeFieldMultiTSWithoutSDA *ret=_content;
7940 throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS : content is expected to be not null !");
7944 const MEDFileAnyTypeFieldMultiTSWithoutSDA *MEDFileAnyTypeFieldMultiTS::contentNotNullBase() const
7946 const MEDFileAnyTypeFieldMultiTSWithoutSDA *ret=_content;
7948 throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS : const content is expected to be not null !");
7952 std::vector<std::string> MEDFileAnyTypeFieldMultiTS::getPflsReallyUsed() const
7954 return contentNotNullBase()->getPflsReallyUsed2();
7957 std::vector<std::string> MEDFileAnyTypeFieldMultiTS::getLocsReallyUsed() const
7959 return contentNotNullBase()->getLocsReallyUsed2();
7962 std::vector<std::string> MEDFileAnyTypeFieldMultiTS::getPflsReallyUsedMulti() const
7964 return contentNotNullBase()->getPflsReallyUsedMulti2();
7967 std::vector<std::string> MEDFileAnyTypeFieldMultiTS::getLocsReallyUsedMulti() const
7969 return contentNotNullBase()->getLocsReallyUsedMulti2();
7972 void MEDFileAnyTypeFieldMultiTS::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
7974 contentNotNullBase()->changePflsRefsNamesGen2(mapOfModif);
7977 void MEDFileAnyTypeFieldMultiTS::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
7979 contentNotNullBase()->changeLocsRefsNamesGen2(mapOfModif);
7982 int MEDFileAnyTypeFieldMultiTS::getNumberOfTS() const
7984 return contentNotNullBase()->getNumberOfTS();
7987 void MEDFileAnyTypeFieldMultiTS::eraseEmptyTS()
7989 contentNotNullBase()->eraseEmptyTS();
7992 void MEDFileAnyTypeFieldMultiTS::eraseTimeStepIds(const int *startIds, const int *endIds)
7994 contentNotNullBase()->eraseTimeStepIds(startIds,endIds);
7997 void MEDFileAnyTypeFieldMultiTS::eraseTimeStepIds2(int bg, int end, int step)
7999 contentNotNullBase()->eraseTimeStepIds2(bg,end,step);
8002 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::buildSubPart(const int *startIds, const int *endIds) const
8004 MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> c=contentNotNullBase()->buildFromTimeStepIds(startIds,endIds);
8005 MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> ret=shallowCpy();
8010 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::buildSubPartSlice(int bg, int end, int step) const
8012 MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> c=contentNotNullBase()->buildFromTimeStepIds2(bg,end,step);
8013 MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> ret=shallowCpy();
8018 std::vector< std::pair<int,int> > MEDFileAnyTypeFieldMultiTS::getIterations() const
8020 return contentNotNullBase()->getIterations();
8023 void MEDFileAnyTypeFieldMultiTS::pushBackTimeSteps(const std::vector<MEDFileAnyTypeField1TS *>& f1ts)
8025 for(std::vector<MEDFileAnyTypeField1TS *>::const_iterator it=f1ts.begin();it!=f1ts.end();it++)
8026 pushBackTimeStep(*it);
8029 void MEDFileAnyTypeFieldMultiTS::pushBackTimeStep(MEDFileAnyTypeField1TS *f1ts)
8032 throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::pushBackTimeStep : input pointer is NULL !");
8033 checkCoherencyOfType(f1ts);
8035 MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TS> f1tsSafe(f1ts);
8036 MEDFileAnyTypeField1TSWithoutSDA *c=f1ts->contentNotNullBase();
8038 MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TSWithoutSDA> cSafe(c);
8039 if(!((MEDFileAnyTypeFieldMultiTSWithoutSDA *)_content))
8040 throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTSWithoutSDA::pushBackTimeStep : no content in this !");
8041 _content->pushBackTimeStep(cSafe);
8042 appendGlobs(*f1ts,1e-12);
8045 void MEDFileAnyTypeFieldMultiTS::synchronizeNameScope()
8047 contentNotNullBase()->synchronizeNameScope();
8050 int MEDFileAnyTypeFieldMultiTS::getPosOfTimeStep(int iteration, int order) const
8052 return contentNotNullBase()->getPosOfTimeStep(iteration,order);
8055 int MEDFileAnyTypeFieldMultiTS::getPosGivenTime(double time, double eps) const
8057 return contentNotNullBase()->getPosGivenTime(time,eps);
8060 int MEDFileAnyTypeFieldMultiTS::getNonEmptyLevels(int iteration, int order, const std::string& mname, std::vector<int>& levs) const
8062 return contentNotNullBase()->getNonEmptyLevels(iteration,order,mname,levs);
8065 std::vector< std::vector<TypeOfField> > MEDFileAnyTypeFieldMultiTS::getTypesOfFieldAvailable() const
8067 return contentNotNullBase()->getTypesOfFieldAvailable();
8070 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
8072 return contentNotNullBase()->getFieldSplitedByType(iteration,order,mname,types,typesF,pfls,locs);
8075 std::string MEDFileAnyTypeFieldMultiTS::getName() const
8077 return contentNotNullBase()->getName();
8080 void MEDFileAnyTypeFieldMultiTS::setName(const std::string& name)
8082 contentNotNullBase()->setName(name);
8085 std::string MEDFileAnyTypeFieldMultiTS::getDtUnit() const
8087 return contentNotNullBase()->getDtUnit();
8090 void MEDFileAnyTypeFieldMultiTS::setDtUnit(const std::string& dtUnit)
8092 contentNotNullBase()->setDtUnit(dtUnit);
8095 void MEDFileAnyTypeFieldMultiTS::simpleRepr(int bkOffset, std::ostream& oss, int fmtsId) const
8097 contentNotNullBase()->simpleRepr(bkOffset,oss,fmtsId);
8100 std::vector< std::pair<int,int> > MEDFileAnyTypeFieldMultiTS::getTimeSteps(std::vector<double>& ret1) const
8102 return contentNotNullBase()->getTimeSteps(ret1);
8105 std::string MEDFileAnyTypeFieldMultiTS::getMeshName() const
8107 return contentNotNullBase()->getMeshName();
8110 void MEDFileAnyTypeFieldMultiTS::setMeshName(const std::string& newMeshName)
8112 contentNotNullBase()->setMeshName(newMeshName);
8115 bool MEDFileAnyTypeFieldMultiTS::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab)
8117 return contentNotNullBase()->changeMeshNames(modifTab);
8120 const std::vector<std::string>& MEDFileAnyTypeFieldMultiTS::getInfo() const
8122 return contentNotNullBase()->getInfo();
8125 void MEDFileAnyTypeFieldMultiTS::setInfo(const std::vector<std::string>& info)
8127 return contentNotNullBase()->setInfo(info);
8130 int MEDFileAnyTypeFieldMultiTS::getNumberOfComponents() const
8132 const std::vector<std::string> ret=getInfo();
8133 return (int)ret.size();
8136 void MEDFileAnyTypeFieldMultiTS::writeLL(med_idt fid) const
8138 writeGlobals(fid,*this);
8139 contentNotNullBase()->writeLL(fid,*this);
8143 * Writes \a this field into a MED file specified by its name.
8144 * \param [in] fileName - the MED file name.
8145 * \param [in] mode - the writing mode. For more on \a mode, see \ref AdvMEDLoaderBasics.
8146 * - 2 - erase; an existing file is removed.
8147 * - 1 - append; same data should not be present in an existing file.
8148 * - 0 - overwrite; same data present in an existing file is overwritten.
8149 * \throw If the field name is not set.
8150 * \throw If no field data is set.
8151 * \throw If \a mode == 1 and the same data is present in an existing file.
8153 void MEDFileAnyTypeFieldMultiTS::write(const std::string& fileName, int mode) const
8155 med_access_mode medmod=MEDFileUtilities::TraduceWriteMode(mode);
8156 MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),medmod);
8161 * This method alloc the arrays and load potentially huge arrays contained in this field.
8162 * This method should be called when a MEDFileAnyTypeFieldMultiTS::New constructor has been with false as the last parameter.
8163 * This method can be also called to refresh or reinit values from a file.
8165 * \throw If the fileName is not set or points to a non readable MED file.
8167 void MEDFileAnyTypeFieldMultiTS::loadArrays()
8169 if(getFileName().empty())
8170 throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::loadArrays : the structure does not come from a file !");
8171 MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName().c_str(),MED_ACC_RDONLY);
8172 contentNotNullBase()->loadBigArraysRecursively(fid,*contentNotNullBase());
8176 * This method behaves as MEDFileAnyTypeFieldMultiTS::loadArrays does, the first call, if \a this was built using a file without loading big arrays.
8177 * But once data loaded once, this method does nothing.
8179 * \throw If the fileName is not set or points to a non readable MED file.
8180 * \sa MEDFileAnyTypeFieldMultiTS::loadArrays, MEDFileAnyTypeFieldMultiTS::unloadArrays
8182 void MEDFileAnyTypeFieldMultiTS::loadArraysIfNecessary()
8184 if(!getFileName().empty())
8186 MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName().c_str(),MED_ACC_RDONLY);
8187 contentNotNullBase()->loadBigArraysRecursivelyIfNecessary(fid,*contentNotNullBase());
8192 * This method releases potentially big data arrays and so returns to the same heap memory than status loaded with 'loadAll' parameter set to false.
8193 * \b WARNING, this method does release arrays even if \a this does not come from a load of a MED file.
8194 * So this method can lead to a loss of data. If you want to unload arrays safely call MEDFileAnyTypeFieldMultiTS::unloadArraysWithoutDataLoss instead.
8196 * \sa MEDFileAnyTypeFieldMultiTS::loadArrays, MEDFileAnyTypeFieldMultiTS::loadArraysIfNecessary, MEDFileAnyTypeFieldMultiTS::unloadArraysWithoutDataLoss
8198 void MEDFileAnyTypeFieldMultiTS::unloadArrays()
8200 contentNotNullBase()->unloadArrays();
8204 * 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.
8205 * This method is the symetrical method of MEDFileAnyTypeFieldMultiTS::loadArraysIfNecessary.
8206 * This method is useful to reduce \b safely amount of heap memory necessary for \a this by using MED file as database.
8208 * \sa MEDFileAnyTypeFieldMultiTS::loadArraysIfNecessary
8210 void MEDFileAnyTypeFieldMultiTS::unloadArraysWithoutDataLoss()
8212 if(!getFileName().empty())
8213 contentNotNullBase()->unloadArrays();
8216 std::string MEDFileAnyTypeFieldMultiTS::simpleRepr() const
8218 std::ostringstream oss;
8219 contentNotNullBase()->simpleRepr(0,oss,-1);
8220 simpleReprGlobs(oss);
8224 std::size_t MEDFileAnyTypeFieldMultiTS::getHeapMemorySizeWithoutChildren() const
8226 return MEDFileFieldGlobsReal::getHeapMemorySizeWithoutChildren();
8229 std::vector<const BigMemoryObject *> MEDFileAnyTypeFieldMultiTS::getDirectChildren() const
8231 std::vector<const BigMemoryObject *> ret(MEDFileFieldGlobsReal::getDirectChildren());
8232 if((const MEDFileAnyTypeFieldMultiTSWithoutSDA *)_content)
8233 ret.push_back((const MEDFileAnyTypeFieldMultiTSWithoutSDA *)_content);
8238 * This method returns as MEDFileAnyTypeFieldMultiTS new instances as number of components in \a this.
8239 * The returned instances are deep copy of \a this except that for globals that are share with those contained in \a this.
8240 * ** WARNING ** do no forget to rename the ouput instances to avoid to write n-times in the same MED file field !
8242 std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTS > > MEDFileAnyTypeFieldMultiTS::splitComponents() const
8244 const MEDFileAnyTypeFieldMultiTSWithoutSDA *content(_content);
8246 throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::splitComponents : no content in this ! Unable to split components !");
8247 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > contentsSplit=content->splitComponents();
8248 std::size_t sz(contentsSplit.size());
8249 std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTS > > ret(sz);
8250 for(std::size_t i=0;i<sz;i++)
8252 ret[i]=shallowCpy();
8253 ret[i]->_content=contentsSplit[i];
8259 * This method returns as MEDFileAnyTypeFieldMultiTS new instances as number of discretizations over time steps in \a this.
8260 * The returned instances are deep copy of \a this except that for globals that are share with those contained in \a this.
8262 std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTS > > MEDFileAnyTypeFieldMultiTS::splitDiscretizations() const
8264 const MEDFileAnyTypeFieldMultiTSWithoutSDA *content(_content);
8266 throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::splitDiscretizations : no content in this ! Unable to split discretizations !");
8267 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > contentsSplit=content->splitDiscretizations();
8268 std::size_t sz(contentsSplit.size());
8269 std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTS > > ret(sz);
8270 for(std::size_t i=0;i<sz;i++)
8272 ret[i]=shallowCpy();
8273 ret[i]->_content=contentsSplit[i];
8278 MEDFileAnyTypeFieldMultiTS *MEDFileAnyTypeFieldMultiTS::deepCpy() const
8280 MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> ret=shallowCpy();
8281 if((const MEDFileAnyTypeFieldMultiTSWithoutSDA *)_content)
8282 ret->_content=_content->deepCpy();
8283 ret->deepCpyGlobs(*this);
8287 MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> MEDFileAnyTypeFieldMultiTS::getContent()
8293 * Returns a new MEDFileField1TS or MEDFileIntField1TS holding data of a given time step of \a this field.
8294 * \param [in] iteration - the iteration number of a required time step.
8295 * \param [in] order - the iteration order number of required time step.
8296 * \return MEDFileField1TS * or MEDFileIntField1TS *- a new instance of MEDFileField1TS or MEDFileIntField1TS. The caller is to
8297 * delete this field using decrRef() as it is no more needed.
8298 * \throw If there is no required time step in \a this field.
8300 MEDFileAnyTypeField1TS *MEDFileAnyTypeFieldMultiTS::getTimeStep(int iteration, int order) const
8302 int pos=getPosOfTimeStep(iteration,order);
8303 return getTimeStepAtPos(pos);
8307 * Returns a new MEDFileField1TS or MEDFileIntField1TS holding data of a given time step of \a this field.
8308 * \param [in] time - the time of the time step of interest.
8309 * \param [in] eps - a precision used to compare time values.
8310 * \return MEDFileField1TS * - a new instance of MEDFileField1TS. The caller is to
8311 * delete this field using decrRef() as it is no more needed.
8312 * \throw If there is no required time step in \a this field.
8314 MEDFileAnyTypeField1TS *MEDFileAnyTypeFieldMultiTS::getTimeStepGivenTime(double time, double eps) const
8316 int pos=getPosGivenTime(time,eps);
8317 return getTimeStepAtPos(pos);
8321 * 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.
8322 * The float64 value of time attached to the pair of integers are not considered here.
8323 * WARNING the returned pointers are not incremented. The caller is \b not responsible to deallocate them ! This method only reorganizes entries in \a vectFMTS.
8325 * \param [in] vectFMTS - vector of not null fields defined on a same global data pointer.
8326 * \throw If there is a null pointer in \a vectFMTS.
8328 std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > MEDFileAnyTypeFieldMultiTS::SplitIntoCommonTimeSeries(const std::vector<MEDFileAnyTypeFieldMultiTS *>& vectFMTS)
8330 static const char msg[]="MEDFileAnyTypeFieldMultiTS::SplitIntoCommonTimeSeries : presence of null instance in input vector !";
8331 std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > ret;
8332 std::list<MEDFileAnyTypeFieldMultiTS *> lstFMTS(vectFMTS.begin(),vectFMTS.end());
8333 while(!lstFMTS.empty())
8335 std::list<MEDFileAnyTypeFieldMultiTS *>::iterator it(lstFMTS.begin());
8336 MEDFileAnyTypeFieldMultiTS *curIt(*it);
8338 throw INTERP_KERNEL::Exception(msg);
8339 std::vector< std::pair<int,int> > refIts=curIt->getIterations();
8340 std::vector<MEDFileAnyTypeFieldMultiTS *> elt;
8341 elt.push_back(curIt); it=lstFMTS.erase(it);
8342 while(it!=lstFMTS.end())
8346 throw INTERP_KERNEL::Exception(msg);
8347 std::vector< std::pair<int,int> > curIts=curIt->getIterations();
8349 { elt.push_back(curIt); it=lstFMTS.erase(it); }
8359 * This method splits the input list \a vectFMTS considering the aspect of the geometrical support over time.
8360 * All returned instances in a subvector can be safely loaded, rendered along time
8361 * All items must be defined on the same time step ids ( see MEDFileAnyTypeFieldMultiTS::SplitIntoCommonTimeSeries method ).
8362 * Each item in \a vectFMTS is expected to have one and exactly one spatial discretization along time.
8363 * 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).
8364 * All items in \a vectFMTS whose spatial discretization is not ON_NODES will appear once.
8365 * 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.
8367 * \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().
8368 * \param [in] mesh - the mesh shared by all items in \a vectFMTS across time.
8369 * \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.
8370 * \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.
8372 * \throw If an element in \a vectFMTS has not only one spatial discretization set.
8373 * \throw If an element in \a vectFMTS change of spatial discretization along time.
8374 * \throw If an element in \a vectFMTS lies on a mesh with meshname different from those in \a mesh.
8375 * \thorw If some elements in \a vectFMTS do not have the same times steps.
8376 * \throw If mesh is null.
8377 * \throw If an element in \a vectFMTS is null.
8378 * \sa MEDFileAnyTypeFieldMultiTS::AreOnSameSupportAcrossTime
8380 std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > MEDFileAnyTypeFieldMultiTS::SplitPerCommonSupport(const std::vector<MEDFileAnyTypeFieldMultiTS *>& vectFMTS, const MEDFileMesh *mesh, std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFastCellSupportComparator> >& fsc)
8382 static const char msg[]="MEDFileAnyTypeFieldMultiTS::SplitPerCommonSupport : presence of a null instance in the input vector !";
8384 throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::SplitPerCommonSupport : input mesh is null !");
8385 std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > ret;
8386 if(vectFMTS.empty())
8388 std::vector<MEDFileAnyTypeFieldMultiTS *>::const_iterator it(vectFMTS.begin());
8389 MEDFileAnyTypeFieldMultiTS *frstElt(*it);
8391 throw INTERP_KERNEL::Exception(msg);
8393 std::vector<MEDFileAnyTypeFieldMultiTS *> vectFMTSNotNodes;
8394 std::vector<MEDFileAnyTypeFieldMultiTS *> vectFMTSNodes;
8395 for(;it!=vectFMTS.end();it++,i++)
8398 throw INTERP_KERNEL::Exception(msg);
8399 TypeOfField tof0,tof1;
8400 if(CheckSupportAcrossTime(frstElt,*it,mesh,tof0,tof1)>0)
8403 vectFMTSNotNodes.push_back(*it);
8405 vectFMTSNodes.push_back(*it);
8408 vectFMTSNotNodes.push_back(*it);
8410 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFastCellSupportComparator> > cmps;
8411 std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > retCell=SplitPerCommonSupportNotNodesAlg(vectFMTSNotNodes,mesh,cmps);
8413 for(std::vector<MEDFileAnyTypeFieldMultiTS *>::const_iterator it2=vectFMTSNodes.begin();it2!=vectFMTSNodes.end();it2++)
8416 bool isFetched(false);
8417 for(std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> >::const_iterator it0=retCell.begin();it0!=retCell.end();it0++,i++)
8420 throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::SplitPerCommonSupport : internal error !");
8421 if(cmps[i]->isCompatibleWithNodesDiscr(*it2))
8422 { ret[i].push_back(*it2); isFetched=true; }
8426 std::vector<MEDFileAnyTypeFieldMultiTS *> tmp(1,*it2);
8427 MEDCouplingAutoRefCountObjectPtr<MEDFileMeshStruct> tmp2(MEDFileMeshStruct::New(mesh));
8428 ret.push_back(tmp); retCell.push_back(tmp); cmps.push_back(MEDFileFastCellSupportComparator::New(tmp2,*it2));
8436 * 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.
8437 * \param [out] cmps - same size than the returned vector.
8439 std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > MEDFileAnyTypeFieldMultiTS::SplitPerCommonSupportNotNodesAlg(const std::vector<MEDFileAnyTypeFieldMultiTS *>& vectFMTS, const MEDFileMesh *mesh, std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileFastCellSupportComparator> >& cmps)
8441 std::vector< std::vector<MEDFileAnyTypeFieldMultiTS *> > ret;
8442 std::list<MEDFileAnyTypeFieldMultiTS *> lstFMTS(vectFMTS.begin(),vectFMTS.end());
8443 while(!lstFMTS.empty())
8445 std::list<MEDFileAnyTypeFieldMultiTS *>::iterator it(lstFMTS.begin());
8446 MEDFileAnyTypeFieldMultiTS *ref(*it);
8447 std::vector<MEDFileAnyTypeFieldMultiTS *> elt;
8448 elt.push_back(ref); it=lstFMTS.erase(it);
8449 MEDCouplingAutoRefCountObjectPtr<MEDFileMeshStruct> mst(MEDFileMeshStruct::New(mesh));
8450 MEDCouplingAutoRefCountObjectPtr<MEDFileFastCellSupportComparator> cmp(MEDFileFastCellSupportComparator::New(mst,ref));
8451 while(it!=lstFMTS.end())
8453 MEDFileAnyTypeFieldMultiTS *curIt(*it);
8454 if(cmp->isEqual(curIt))
8455 { elt.push_back(curIt); it=lstFMTS.erase(it); }
8459 ret.push_back(elt); cmps.push_back(cmp);
8465 * 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.
8466 * \a f0 and \a f1 must be defined each only on a same spatial discretization even if this can be different each other.
8468 * \throw If \a f0 or \a f1 has not only one spatial discretization set.
8469 * \throw If \a f0 or \a f1 change of spatial discretization along time.
8470 * \throw If \a f0 or \a f1 on a mesh with meshname different from those in \a mesh.
8471 * \thorw If \a f0 and \a f1 do not have the same times steps.
8472 * \throw If mesh is null.
8473 * \throw If \a f0 or \a f1 is null.
8474 * \sa MEDFileAnyTypeFieldMultiTS::SplitPerCommonSupport
8476 int MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime(MEDFileAnyTypeFieldMultiTS *f0, MEDFileAnyTypeFieldMultiTS *f1, const MEDFileMesh *mesh, TypeOfField& tof0, TypeOfField& tof1)
8479 throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : input mesh is null !");
8481 throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : presence of null instance in fields over time !");
8482 if(f0->getMeshName()!=mesh->getName())
8484 std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : first field points to mesh \""<< f0->getMeshName() << "\" and input mesh to compare has name \"" << mesh->getName() << "\" !";
8485 throw INTERP_KERNEL::Exception(oss.str().c_str());
8487 if(f1->getMeshName()!=mesh->getName())
8489 std::ostringstream oss; oss << "MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : second field points to mesh \""<< f1->getMeshName() << "\" and input mesh to compare has name \"" << mesh->getName() << "\" !";
8490 throw INTERP_KERNEL::Exception(oss.str().c_str());
8492 int nts=f0->getNumberOfTS();
8493 if(nts!=f1->getNumberOfTS())
8494 throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : number of time steps are not the same !");
8497 for(int i=0;i<nts;i++)
8499 MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TS> f0cur=f0->getTimeStepAtPos(i);
8500 MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TS> f1cur=f1->getTimeStepAtPos(i);
8501 std::vector<TypeOfField> tofs0(f0cur->getTypesOfFieldAvailable()),tofs1(f1cur->getTypesOfFieldAvailable());
8502 if(tofs0.size()!=1 || tofs1.size()!=1)
8503 throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : All time steps must be defined on only one spatial discretization !");
8506 if(tof0!=tofs0[0] || tof1!=tofs1[0])
8507 throw INTERP_KERNEL::Exception("MEDFileAnyTypeFieldMultiTS::CheckSupportAcrossTime : Across times steps MEDFileAnyTypeFieldMultiTS instances have to keep the same unique spatial discretization !");
8510 { tof0=tofs0[0]; tof1=tofs1[0]; }
8511 if(f0cur->getMeshIteration()!=mesh->getIteration() || f0cur->getMeshOrder()!=mesh->getOrder())
8513 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() << ") !";
8514 throw INTERP_KERNEL::Exception(oss.str().c_str());
8516 if(f1cur->getMeshIteration()!=mesh->getIteration() || f1cur->getMeshOrder()!=mesh->getOrder())
8518 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() << ") !";
8519 throw INTERP_KERNEL::Exception(oss.str().c_str());
8521 if(f0cur->getIteration()!=f1cur->getIteration() || f0cur->getOrder()!=f1cur->getOrder())
8523 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() << ") !";
8524 throw INTERP_KERNEL::Exception(oss.str().c_str());
8530 MEDFileAnyTypeFieldMultiTSIterator *MEDFileAnyTypeFieldMultiTS::iterator()
8532 return new MEDFileAnyTypeFieldMultiTSIterator(this);
8535 //= MEDFileFieldMultiTS
8538 * Returns a new empty instance of MEDFileFieldMultiTS.
8539 * \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS. The caller
8540 * is to delete this field using decrRef() as it is no more needed.
8542 MEDFileFieldMultiTS *MEDFileFieldMultiTS::New()
8544 return new MEDFileFieldMultiTS;
8548 * Returns a new instance of MEDFileFieldMultiTS holding data of the first field
8549 * that has been read from a specified MED file.
8550 * \param [in] fileName - the name of the MED file to read.
8551 * \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS. The caller
8552 * is to delete this field using decrRef() as it is no more needed.
8553 * \throw If reading the file fails.
8555 MEDFileFieldMultiTS *MEDFileFieldMultiTS::New(const std::string& fileName, bool loadAll)
8557 MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTS> ret=new MEDFileFieldMultiTS(fileName,loadAll);
8558 ret->contentNotNull();//to check that content type matches with \a this type.
8563 * Returns a new instance of MEDFileFieldMultiTS holding data of a given field
8564 * that has been read from a specified MED file.
8565 * \param [in] fileName - the name of the MED file to read.
8566 * \param [in] fieldName - the name of the field to read.
8567 * \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS. The caller
8568 * is to delete this field using decrRef() as it is no more needed.
8569 * \throw If reading the file fails.
8570 * \throw If there is no field named \a fieldName in the file.
8572 MEDFileFieldMultiTS *MEDFileFieldMultiTS::New(const std::string& fileName, const std::string& fieldName, bool loadAll)
8574 MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTS> ret=new MEDFileFieldMultiTS(fileName,fieldName,loadAll);
8575 ret->contentNotNull();//to check that content type matches with \a this type.
8580 * Returns a new instance of MEDFileFieldMultiTS. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
8581 * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
8583 * Returns a new instance of MEDFileFieldMultiTS holding either a shallow copy
8584 * of a given MEDFileFieldMultiTSWithoutSDA ( \a other ) or \a other itself.
8585 * \warning this is a shallow copy constructor
8586 * \param [in] other - a MEDFileField1TSWithoutSDA to copy.
8587 * \param [in] shallowCopyOfContent - if \c true, a shallow copy of \a other is created.
8588 * \return MEDFileFieldMultiTS * - a new instance of MEDFileFieldMultiTS. The caller
8589 * is to delete this field using decrRef() as it is no more needed.
8591 MEDFileFieldMultiTS *MEDFileFieldMultiTS::New(const MEDFileFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent)
8593 return new MEDFileFieldMultiTS(other,shallowCopyOfContent);
8596 MEDFileAnyTypeFieldMultiTS *MEDFileFieldMultiTS::shallowCpy() const
8598 return new MEDFileFieldMultiTS(*this);
8601 void MEDFileFieldMultiTS::checkCoherencyOfType(const MEDFileAnyTypeField1TS *f1ts) const
8604 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::checkCoherencyOfType : input field1TS is NULL ! Impossible to check !");
8605 const MEDFileField1TS *f1tsC=dynamic_cast<const MEDFileField1TS *>(f1ts);
8607 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::checkCoherencyOfType : the input field1TS is not a FLOAT64 type !");
8611 * This method performs a copy with datatype modification ( float64->int32 ) of \a this. The globals information are copied
8612 * following the given input policy.
8614 * \param [in] isDeepCpyGlobs - a boolean that indicates the behaviour concerning globals (profiles and localizations)
8615 * By default (true) the globals are deeply copied.
8616 * \return MEDFileIntFieldMultiTS * - a new object that is the result of the conversion of \a this to int32 field.
8618 MEDFileIntFieldMultiTS *MEDFileFieldMultiTS::convertToInt(bool isDeepCpyGlobs) const
8620 MEDCouplingAutoRefCountObjectPtr<MEDFileIntFieldMultiTS> ret;
8621 const MEDFileAnyTypeFieldMultiTSWithoutSDA *content(_content);
8624 const MEDFileFieldMultiTSWithoutSDA *contc=dynamic_cast<const MEDFileFieldMultiTSWithoutSDA *>(content);
8626 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::convertToInt : the content inside this is not FLOAT64 ! This is incoherent !");
8627 MEDCouplingAutoRefCountObjectPtr<MEDFileIntFieldMultiTSWithoutSDA> newc(contc->convertToInt());
8628 ret=static_cast<MEDFileIntFieldMultiTS *>(MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent((MEDFileIntFieldMultiTSWithoutSDA *)newc,getFileName()));
8631 ret=MEDFileIntFieldMultiTS::New();
8633 ret->deepCpyGlobs(*this);
8635 ret->shallowCpyGlobs(*this);
8640 * Returns a new MEDFileField1TS holding data of a given time step of \a this field.
8641 * \param [in] pos - a time step id.
8642 * \return MEDFileField1TS * - a new instance of MEDFileField1TS. The caller is to
8643 * delete this field using decrRef() as it is no more needed.
8644 * \throw If \a pos is not a valid time step id.
8646 MEDFileAnyTypeField1TS *MEDFileFieldMultiTS::getTimeStepAtPos(int pos) const
8648 const MEDFileAnyTypeField1TSWithoutSDA *item=contentNotNullBase()->getTimeStepAtPos2(pos);
8651 std::ostringstream oss; oss << "MEDFileFieldMultiTS::getTimeStepAtPos : field at pos #" << pos << " is null !";
8652 throw INTERP_KERNEL::Exception(oss.str().c_str());
8654 const MEDFileField1TSWithoutSDA *itemC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(item);
8657 MEDCouplingAutoRefCountObjectPtr<MEDFileField1TS> ret=MEDFileField1TS::New(*itemC,false);
8658 ret->shallowCpyGlobs(*this);
8661 std::ostringstream oss; oss << "MEDFileFieldMultiTS::getTimeStepAtPos : type of field at pos #" << pos << " is not FLOAT64 !";
8662 throw INTERP_KERNEL::Exception(oss.str().c_str());
8666 * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
8667 * mesh entities of a given dimension of the first mesh in MED file.
8668 * For more info, see \ref AdvMEDLoaderAPIFieldRW
8669 * \param [in] type - a spatial discretization of interest.
8670 * \param [in] iteration - the iteration number of a required time step.
8671 * \param [in] order - the iteration order number of required time step.
8672 * \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
8673 * \param [in] renumPol - specifies how to permute values of the result field according to
8674 * the optional numbers of cells and nodes, if any. The valid values are
8675 * - 0 - do not permute.
8676 * - 1 - permute cells.
8677 * - 2 - permute nodes.
8678 * - 3 - permute cells and nodes.
8680 * \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
8681 * caller is to delete this field using decrRef() as it is no more needed.
8682 * \throw If the MED file is not readable.
8683 * \throw If there is no mesh in the MED file.
8684 * \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
8685 * \throw If no field values of the required parameters are available.
8687 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldAtLevel(TypeOfField type, int iteration, int order, int meshDimRelToMax, int renumPol) const
8689 const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8690 const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
8692 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldAtLevel : mismatch of type of field expecting FLOAT64 !");
8693 MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
8694 MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtLevel(type,meshDimRelToMax,std::string(),renumPol,this,arrOut,*contentNotNullBase());
8695 MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
8700 * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
8701 * the top level cells of the first mesh in MED file.
8702 * For more info, see \ref AdvMEDLoaderAPIFieldRW
8703 * \param [in] type - a spatial discretization of interest.
8704 * \param [in] iteration - the iteration number of a required time step.
8705 * \param [in] order - the iteration order number of required time step.
8706 * \param [in] renumPol - specifies how to permute values of the result field according to
8707 * the optional numbers of cells and nodes, if any. The valid values are
8708 * - 0 - do not permute.
8709 * - 1 - permute cells.
8710 * - 2 - permute nodes.
8711 * - 3 - permute cells and nodes.
8713 * \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
8714 * caller is to delete this field using decrRef() as it is no more needed.
8715 * \throw If the MED file is not readable.
8716 * \throw If there is no mesh in the MED file.
8717 * \throw If no field values of the required parameters are available.
8719 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldAtTopLevel(TypeOfField type, int iteration, int order, int renumPol) const
8721 const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8722 const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
8724 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldAtTopLevel : mismatch of type of field !");
8725 MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
8726 MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtTopLevel(type,std::string(),renumPol,this,arrOut,*contentNotNullBase());
8727 MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
8732 * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
8734 * For more info, see \ref AdvMEDLoaderAPIFieldRW
8735 * \param [in] type - a spatial discretization of interest.
8736 * \param [in] iteration - the iteration number of a required time step.
8737 * \param [in] order - the iteration order number of required time step.
8738 * \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
8739 * \param [in] mesh - the supporting mesh.
8740 * \param [in] renumPol - specifies how to permute values of the result field according to
8741 * the optional numbers of cells and nodes, if any. The valid values are
8742 * - 0 - do not permute.
8743 * - 1 - permute cells.
8744 * - 2 - permute nodes.
8745 * - 3 - permute cells and nodes.
8747 * \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
8748 * caller is to delete this field using decrRef() as it is no more needed.
8749 * \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
8750 * \throw If no field of \a this is lying on \a mesh.
8751 * \throw If no field values of the required parameters are available.
8753 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldOnMeshAtLevel(TypeOfField type, int iteration, int order, int meshDimRelToMax, const MEDFileMesh *mesh, int renumPol) const
8755 const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8756 const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
8758 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldOnMeshAtLevel : mismatch of type of field !");
8759 MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
8760 MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,this,mesh,arrOut,*contentNotNullBase());
8761 MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
8766 * Returns a new MEDCouplingFieldDouble of given type, of a given time step, lying on a
8768 * For more info, see \ref AdvMEDLoaderAPIFieldRW
8769 * \param [in] type - a spatial discretization of the new field.
8770 * \param [in] iteration - the iteration number of a required time step.
8771 * \param [in] order - the iteration order number of required time step.
8772 * \param [in] mesh - the supporting mesh.
8773 * \param [in] renumPol - specifies how to permute values of the result field according to
8774 * the optional numbers of cells and nodes, if any. The valid values are
8775 * - 0 - do not permute.
8776 * - 1 - permute cells.
8777 * - 2 - permute nodes.
8778 * - 3 - permute cells and nodes.
8780 * \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
8781 * caller is to delete this field using decrRef() as it is no more needed.
8782 * \throw If no field of \a this is lying on \a mesh.
8783 * \throw If no field values of the required parameters are available.
8785 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldOnMeshAtLevel(TypeOfField type, int iteration, int order, const MEDCouplingMesh *mesh, int renumPol) const
8787 const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8788 const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
8790 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldOnMeshAtLevel : mismatch of type of field !");
8791 MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
8792 MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldOnMeshAtLevel(type,renumPol,this,mesh,0,0,arrOut,*contentNotNullBase());
8793 MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
8798 * This method has a close behaviour than MEDFileFieldMultiTS::getFieldAtLevel.
8799 * This method is called 'old' because the user should give the mesh name he wants to use for it's field.
8800 * This method is useful for MED2 file format when field on different mesh was autorized.
8802 MEDCouplingFieldDouble *MEDFileFieldMultiTS::getFieldAtLevelOld(TypeOfField type, const std::string& mname, int iteration, int order, int meshDimRelToMax, int renumPol) const
8804 const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8805 const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
8807 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldAtLevelOld : mismatch of type of field !");
8808 MEDCouplingAutoRefCountObjectPtr<DataArray> arrOut;
8809 MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtLevel(type,meshDimRelToMax,mname,renumPol,this,arrOut,*contentNotNullBase());
8810 MEDFileField1TS::SetDataArrayDoubleInField(ret,arrOut);
8815 * Returns values and a profile of the field of a given type, of a given time step,
8816 * lying on a given support.
8817 * For more info, see \ref AdvMEDLoaderAPIFieldRW
8818 * \param [in] type - a spatial discretization of the field.
8819 * \param [in] iteration - the iteration number of a required time step.
8820 * \param [in] order - the iteration order number of required time step.
8821 * \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
8822 * \param [in] mesh - the supporting mesh.
8823 * \param [out] pfl - a new instance of DataArrayInt holding ids of mesh entities the
8824 * field of interest lies on. If the field lies on all entities of the given
8825 * dimension, all ids in \a pfl are zero. The caller is to delete this array
8826 * using decrRef() as it is no more needed.
8827 * \param [in] glob - the global data storing profiles and localization.
8828 * \return DataArrayDouble * - a new instance of DataArrayDouble holding values of the
8829 * field. The caller is to delete this array using decrRef() as it is no more needed.
8830 * \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
8831 * \throw If no field of \a this is lying on \a mesh.
8832 * \throw If no field values of the required parameters are available.
8834 DataArrayDouble *MEDFileFieldMultiTS::getFieldWithProfile(TypeOfField type, int iteration, int order, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt *&pfl) const
8836 const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
8837 const MEDFileField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileField1TSWithoutSDA *>(&myF1TS);
8839 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldWithProfile : mismatch of type of field !");
8840 MEDCouplingAutoRefCountObjectPtr<DataArray> ret=myF1TSC->getFieldWithProfile(type,meshDimRelToMax,mesh,pfl,this,*contentNotNullBase());
8841 return MEDFileField1TS::ReturnSafelyDataArrayDouble(ret);
8844 const MEDFileFieldMultiTSWithoutSDA *MEDFileFieldMultiTS::contentNotNull() const
8846 const MEDFileAnyTypeFieldMultiTSWithoutSDA *pt(_content);
8848 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::contentNotNull : the content pointer is null !");
8849 const MEDFileFieldMultiTSWithoutSDA *ret=dynamic_cast<const MEDFileFieldMultiTSWithoutSDA *>(pt);
8851 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 !");
8855 MEDFileFieldMultiTSWithoutSDA *MEDFileFieldMultiTS::contentNotNull()
8857 MEDFileAnyTypeFieldMultiTSWithoutSDA *pt(_content);
8859 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::contentNotNull : the non const content pointer is null !");
8860 MEDFileFieldMultiTSWithoutSDA *ret=dynamic_cast<MEDFileFieldMultiTSWithoutSDA *>(pt);
8862 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 !");
8867 * Adds a MEDCouplingFieldDouble to \a this as another time step. The underlying mesh of
8868 * the given field is checked if its elements are sorted suitable for writing to MED file
8869 * ("STB" stands for "Sort By Type"), if not, an exception is thrown.
8870 * For more info, see \ref AdvMEDLoaderAPIFieldRW
8871 * \param [in] field - the field to add to \a this.
8872 * \throw If the name of \a field is empty.
8873 * \throw If the data array of \a field is not set.
8874 * \throw If existing time steps have different name or number of components than \a field.
8875 * \throw If the underlying mesh of \a field has no name.
8876 * \throw If elements in the mesh are not in the order suitable for writing to the MED file.
8878 void MEDFileFieldMultiTS::appendFieldNoProfileSBT(const MEDCouplingFieldDouble *field)
8880 const DataArrayDouble *arr=0;
8882 arr=field->getArray();
8883 contentNotNull()->appendFieldNoProfileSBT(field,arr,*this);
8887 * Adds a MEDCouplingFieldDouble to \a this as another time step.
8888 * The mesh support of input parameter \a field is ignored here, it can be NULL.
8889 * The support of field \a field is expected to be those computed with the input parameter \a mesh, \a meshDimRelToMax,
8892 * This method will check that the field based on the computed support is coherent. If not an exception will be thrown.
8893 * A new profile is added only if no equal profile is missing.
8894 * For more info, see \ref AdvMEDLoaderAPIFieldRW
8895 * \param [in] field - the field to add to \a this. The mesh support of field is ignored.
8896 * \param [in] mesh - the supporting mesh of \a field.
8897 * \param [in] meshDimRelToMax - a relative dimension of mesh entities \a field lies on (useless if field spatial discretization is ON_NODES).
8898 * \param [in] profile - ids of mesh entities on which corresponding field values lie.
8899 * \throw If either \a field or \a mesh or \a profile has an empty name.
8900 * \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
8901 * \throw If the data array of \a field is not set.
8902 * \throw If the data array of \a this is already allocated but has different number of
8903 * components than \a field.
8904 * \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
8905 * \sa setFieldNoProfileSBT()
8907 void MEDFileFieldMultiTS::appendFieldProfile(const MEDCouplingFieldDouble *field, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile)
8909 const DataArrayDouble *arr=0;
8911 arr=field->getArray();
8912 contentNotNull()->appendFieldProfile(field,arr,mesh,meshDimRelToMax,profile,*this);
8915 MEDFileFieldMultiTS::MEDFileFieldMultiTS()
8917 _content=new MEDFileFieldMultiTSWithoutSDA;
8920 MEDFileFieldMultiTS::MEDFileFieldMultiTS(const std::string& fileName, bool loadAll)
8921 try:MEDFileAnyTypeFieldMultiTS(fileName,loadAll)
8924 catch(INTERP_KERNEL::Exception& e)
8927 MEDFileFieldMultiTS::MEDFileFieldMultiTS(const std::string& fileName, const std::string& fieldName, bool loadAll)
8928 try:MEDFileAnyTypeFieldMultiTS(fileName,fieldName,loadAll)
8931 catch(INTERP_KERNEL::Exception& e)
8934 MEDFileFieldMultiTS::MEDFileFieldMultiTS(const MEDFileFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent):MEDFileAnyTypeFieldMultiTS(other,shallowCopyOfContent)
8938 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
8940 return contentNotNull()->getFieldSplitedByType2(iteration,order,mname,types,typesF,pfls,locs);
8943 DataArrayDouble *MEDFileFieldMultiTS::getUndergroundDataArray(int iteration, int order) const
8945 return static_cast<DataArrayDouble *>(contentNotNull()->getUndergroundDataArray(iteration,order));
8948 DataArrayDouble *MEDFileFieldMultiTS::getUndergroundDataArrayExt(int iteration, int order, std::vector< std::pair<std::pair<INTERP_KERNEL::NormalizedCellType,int>,std::pair<int,int> > >& entries) const
8950 return static_cast<DataArrayDouble *>(contentNotNull()->getUndergroundDataArrayExt(iteration,order,entries));
8953 //= MEDFileAnyTypeFieldMultiTSIterator
8955 MEDFileAnyTypeFieldMultiTSIterator::MEDFileAnyTypeFieldMultiTSIterator(MEDFileAnyTypeFieldMultiTS *fmts):_fmts(fmts),_iter_id(0),_nb_iter(0)
8960 _nb_iter=fmts->getNumberOfTS();
8964 MEDFileAnyTypeFieldMultiTSIterator::~MEDFileAnyTypeFieldMultiTSIterator()
8968 MEDFileAnyTypeField1TS *MEDFileAnyTypeFieldMultiTSIterator::nextt()
8970 if(_iter_id<_nb_iter)
8972 MEDFileAnyTypeFieldMultiTS *fmts(_fmts);
8974 return fmts->getTimeStepAtPos(_iter_id++);
8982 //= MEDFileIntFieldMultiTS
8985 * Returns a new empty instance of MEDFileFieldMultiTS.
8986 * \return MEDFileIntFieldMultiTS * - a new instance of MEDFileIntFieldMultiTS. The caller
8987 * is to delete this field using decrRef() as it is no more needed.
8989 MEDFileIntFieldMultiTS *MEDFileIntFieldMultiTS::New()
8991 return new MEDFileIntFieldMultiTS;
8995 * Returns a new instance of MEDFileIntFieldMultiTS holding data of the first field
8996 * that has been read from a specified MED file.
8997 * \param [in] fileName - the name of the MED file to read.
8998 * \return MEDFileFieldMultiTS * - a new instance of MEDFileIntFieldMultiTS. The caller
8999 * is to delete this field using decrRef() as it is no more needed.
9000 * \throw If reading the file fails.
9002 MEDFileIntFieldMultiTS *MEDFileIntFieldMultiTS::New(const std::string& fileName, bool loadAll)
9004 MEDCouplingAutoRefCountObjectPtr<MEDFileIntFieldMultiTS> ret=new MEDFileIntFieldMultiTS(fileName,loadAll);
9005 ret->contentNotNull();//to check that content type matches with \a this type.
9010 * Returns a new instance of MEDFileIntFieldMultiTS holding data of a given field
9011 * that has been read from a specified MED file.
9012 * \param [in] fileName - the name of the MED file to read.
9013 * \param [in] fieldName - the name of the field to read.
9014 * \return MEDFileFieldMultiTS * - a new instance of MEDFileIntFieldMultiTS. The caller
9015 * is to delete this field using decrRef() as it is no more needed.
9016 * \throw If reading the file fails.
9017 * \throw If there is no field named \a fieldName in the file.
9019 MEDFileIntFieldMultiTS *MEDFileIntFieldMultiTS::New(const std::string& fileName, const std::string& fieldName, bool loadAll)
9021 MEDCouplingAutoRefCountObjectPtr<MEDFileIntFieldMultiTS> ret=new MEDFileIntFieldMultiTS(fileName,fieldName,loadAll);
9022 ret->contentNotNull();//to check that content type matches with \a this type.
9027 * Returns a new instance of MEDFileIntFieldMultiTS. If \a shallowCopyOfContent is true the content of \a other is shallow copied.
9028 * If \a shallowCopyOfContent is false, \a other is taken to be the content of \a this.
9030 * Returns a new instance of MEDFileIntFieldMultiTS holding either a shallow copy
9031 * of a given MEDFileIntFieldMultiTSWithoutSDA ( \a other ) or \a other itself.
9032 * \warning this is a shallow copy constructor
9033 * \param [in] other - a MEDFileIntField1TSWithoutSDA to copy.
9034 * \param [in] shallowCopyOfContent - if \c true, a shallow copy of \a other is created.
9035 * \return MEDFileIntFieldMultiTS * - a new instance of MEDFileIntFieldMultiTS. The caller
9036 * is to delete this field using decrRef() as it is no more needed.
9038 MEDFileIntFieldMultiTS *MEDFileIntFieldMultiTS::New(const MEDFileIntFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent)
9040 return new MEDFileIntFieldMultiTS(other,shallowCopyOfContent);
9044 * This method performs a copy with datatype modification ( int32->float64 ) of \a this. The globals information are copied
9045 * following the given input policy.
9047 * \param [in] isDeepCpyGlobs - a boolean that indicates the behaviour concerning globals (profiles and localizations)
9048 * By default (true) the globals are deeply copied.
9049 * \return MEDFileFieldMultiTS * - a new object that is the result of the conversion of \a this to float64 field.
9051 MEDFileFieldMultiTS *MEDFileIntFieldMultiTS::convertToDouble(bool isDeepCpyGlobs) const
9053 MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTS> ret;
9054 const MEDFileAnyTypeFieldMultiTSWithoutSDA *content(_content);
9057 const MEDFileIntFieldMultiTSWithoutSDA *contc=dynamic_cast<const MEDFileIntFieldMultiTSWithoutSDA *>(content);
9059 throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::convertToInt : the content inside this is not INT32 ! This is incoherent !");
9060 MEDCouplingAutoRefCountObjectPtr<MEDFileFieldMultiTSWithoutSDA> newc(contc->convertToDouble());
9061 ret=static_cast<MEDFileFieldMultiTS *>(MEDFileAnyTypeFieldMultiTS::BuildNewInstanceFromContent((MEDFileFieldMultiTSWithoutSDA *)newc,getFileName()));
9064 ret=MEDFileFieldMultiTS::New();
9066 ret->deepCpyGlobs(*this);
9068 ret->shallowCpyGlobs(*this);
9072 MEDFileAnyTypeFieldMultiTS *MEDFileIntFieldMultiTS::shallowCpy() const
9074 return new MEDFileIntFieldMultiTS(*this);
9077 void MEDFileIntFieldMultiTS::checkCoherencyOfType(const MEDFileAnyTypeField1TS *f1ts) const
9080 throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::checkCoherencyOfType : input field1TS is NULL ! Impossible to check !");
9081 const MEDFileIntField1TS *f1tsC=dynamic_cast<const MEDFileIntField1TS *>(f1ts);
9083 throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::checkCoherencyOfType : the input field1TS is not a INT32 type !");
9087 * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
9088 * mesh entities of a given dimension of the first mesh in MED file.
9089 * For more info, see \ref AdvMEDLoaderAPIFieldRW
9090 * \param [in] type - a spatial discretization of interest.
9091 * \param [in] iteration - the iteration number of a required time step.
9092 * \param [in] order - the iteration order number of required time step.
9093 * \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
9094 * \param [out] arrOut - the DataArrayInt containing values of field.
9095 * \param [in] renumPol - specifies how to permute values of the result field according to
9096 * the optional numbers of cells and nodes, if any. The valid values are
9097 * - 0 - do not permute.
9098 * - 1 - permute cells.
9099 * - 2 - permute nodes.
9100 * - 3 - permute cells and nodes.
9102 * \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
9103 * caller is to delete this field using decrRef() as it is no more needed.
9104 * \throw If the MED file is not readable.
9105 * \throw If there is no mesh in the MED file.
9106 * \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
9107 * \throw If no field values of the required parameters are available.
9109 MEDCouplingFieldDouble *MEDFileIntFieldMultiTS::getFieldAtLevel(TypeOfField type, int iteration, int order, int meshDimRelToMax, DataArrayInt* &arrOut, int renumPol) const
9111 const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
9112 const MEDFileIntField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS);
9114 throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::getFieldAtLevel : mismatch of type of field expecting INT32 !");
9115 MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
9116 MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtLevel(type,meshDimRelToMax,std::string(),renumPol,this,arr,*contentNotNullBase());
9117 arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
9122 * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
9123 * the top level cells of the first mesh in MED file.
9124 * For more info, see \ref AdvMEDLoaderAPIFieldRW
9125 * \param [in] type - a spatial discretization of interest.
9126 * \param [in] iteration - the iteration number of a required time step.
9127 * \param [in] order - the iteration order number of required time step.
9128 * \param [out] arrOut - the DataArrayInt containing values of field.
9129 * \param [in] renumPol - specifies how to permute values of the result field according to
9130 * the optional numbers of cells and nodes, if any. The valid values are
9131 * - 0 - do not permute.
9132 * - 1 - permute cells.
9133 * - 2 - permute nodes.
9134 * - 3 - permute cells and nodes.
9136 * \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
9137 * caller is to delete this field using decrRef() as it is no more needed.
9138 * \throw If the MED file is not readable.
9139 * \throw If there is no mesh in the MED file.
9140 * \throw If no field values of the required parameters are available.
9142 MEDCouplingFieldDouble *MEDFileIntFieldMultiTS::getFieldAtTopLevel(TypeOfField type, int iteration, int order, DataArrayInt* &arrOut, int renumPol) const
9144 const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
9145 const MEDFileIntField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS);
9147 throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::getFieldAtTopLevel : mismatch of type of field ! INT32 expected !");
9148 MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
9149 MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtTopLevel(type,std::string(),renumPol,this,arr,*contentNotNullBase());
9150 arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
9155 * Returns a new MEDCouplingFieldDouble of a given type, of a given time step, lying on
9157 * For more info, see \ref AdvMEDLoaderAPIFieldRW
9158 * \param [in] type - a spatial discretization of interest.
9159 * \param [in] iteration - the iteration number of a required time step.
9160 * \param [in] order - the iteration order number of required time step.
9161 * \param [out] arrOut - the DataArrayInt containing values of field.
9162 * \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
9163 * \param [in] mesh - the supporting mesh.
9164 * \param [in] renumPol - specifies how to permute values of the result field according to
9165 * the optional numbers of cells and nodes, if any. The valid values are
9166 * - 0 - do not permute.
9167 * - 1 - permute cells.
9168 * - 2 - permute nodes.
9169 * - 3 - permute cells and nodes.
9171 * \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
9172 * caller is to delete this field using decrRef() as it is no more needed.
9173 * \throw If there are no mesh entities of \a meshDimRelToMax dimension in the mesh.
9174 * \throw If no field of \a this is lying on \a mesh.
9175 * \throw If no field values of the required parameters are available.
9177 MEDCouplingFieldDouble *MEDFileIntFieldMultiTS::getFieldOnMeshAtLevel(TypeOfField type, int iteration, int order, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt* &arrOut, int renumPol) const
9179 const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
9180 const MEDFileIntField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS);
9182 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldOnMeshAtLevel : mismatch of type of field ! INT32 expected !");
9183 MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
9184 MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldOnMeshAtLevel(type,meshDimRelToMax,renumPol,this,mesh,arr,*contentNotNullBase());
9185 arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
9190 * Returns a new MEDCouplingFieldDouble of given type, of a given time step, lying on a
9192 * For more info, see \ref AdvMEDLoaderAPIFieldRW
9193 * \param [in] type - a spatial discretization of the new field.
9194 * \param [in] iteration - the iteration number of a required time step.
9195 * \param [in] order - the iteration order number of required time step.
9196 * \param [in] mesh - the supporting mesh.
9197 * \param [out] arrOut - the DataArrayInt containing values of field.
9198 * \param [in] renumPol - specifies how to permute values of the result field according to
9199 * the optional numbers of cells and nodes, if any. The valid values are
9200 * - 0 - do not permute.
9201 * - 1 - permute cells.
9202 * - 2 - permute nodes.
9203 * - 3 - permute cells and nodes.
9205 * \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble. The
9206 * caller is to delete this field using decrRef() as it is no more needed.
9207 * \throw If no field of \a this is lying on \a mesh.
9208 * \throw If no field values of the required parameters are available.
9210 MEDCouplingFieldDouble *MEDFileIntFieldMultiTS::getFieldOnMeshAtLevel(TypeOfField type, int iteration, int order, const MEDCouplingMesh *mesh, DataArrayInt* &arrOut, int renumPol) const
9212 const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
9213 const MEDFileIntField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS);
9215 throw INTERP_KERNEL::Exception("MEDFileFieldIntMultiTS::getFieldOnMeshAtLevel : mismatch of type of field ! INT32 expected !");
9216 MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
9217 MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldOnMeshAtLevel(type,renumPol,this,mesh,0,0,arr,*contentNotNullBase());
9218 arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
9223 * This method has a close behaviour than MEDFileIntFieldMultiTS::getFieldAtLevel.
9224 * This method is called 'old' because the user should give the mesh name he wants to use for it's field.
9225 * This method is useful for MED2 file format when field on different mesh was autorized.
9227 MEDCouplingFieldDouble *MEDFileIntFieldMultiTS::getFieldAtLevelOld(TypeOfField type, int iteration, int order, const std::string& mname, int meshDimRelToMax, DataArrayInt* &arrOut, int renumPol) const
9229 const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
9230 const MEDFileIntField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS);
9232 throw INTERP_KERNEL::Exception("MEDFileFieldMultiTS::getFieldOnMeshAtLevel : mismatch of type of field ! INT32 expected !");
9233 MEDCouplingAutoRefCountObjectPtr<DataArray> arr;
9234 MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=myF1TSC->getFieldAtLevel(type,meshDimRelToMax,mname,renumPol,this,arr,*contentNotNullBase());
9235 arrOut=MEDFileIntField1TS::ReturnSafelyDataArrayInt(arr);
9240 * Returns values and a profile of the field of a given type, of a given time step,
9241 * lying on a given support.
9242 * For more info, see \ref AdvMEDLoaderAPIFieldRW
9243 * \param [in] type - a spatial discretization of the field.
9244 * \param [in] iteration - the iteration number of a required time step.
9245 * \param [in] order - the iteration order number of required time step.
9246 * \param [in] meshDimRelToMax - a relative dimension of the supporting mesh entities.
9247 * \param [in] mesh - the supporting mesh.
9248 * \param [out] pfl - a new instance of DataArrayInt holding ids of mesh entities the
9249 * field of interest lies on. If the field lies on all entities of the given
9250 * dimension, all ids in \a pfl are zero. The caller is to delete this array
9251 * using decrRef() as it is no more needed.
9252 * \param [in] glob - the global data storing profiles and localization.
9253 * \return DataArrayInt * - a new instance of DataArrayInt holding values of the
9254 * field. The caller is to delete this array using decrRef() as it is no more needed.
9255 * \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
9256 * \throw If no field of \a this is lying on \a mesh.
9257 * \throw If no field values of the required parameters are available.
9259 DataArrayInt *MEDFileIntFieldMultiTS::getFieldWithProfile(TypeOfField type, int iteration, int order, int meshDimRelToMax, const MEDFileMesh *mesh, DataArrayInt *&pfl) const
9261 const MEDFileAnyTypeField1TSWithoutSDA& myF1TS=contentNotNullBase()->getTimeStepEntry(iteration,order);
9262 const MEDFileIntField1TSWithoutSDA *myF1TSC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(&myF1TS);
9264 throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::getFieldWithProfile : mismatch of type of field ! INT32 expected !");
9265 MEDCouplingAutoRefCountObjectPtr<DataArray> ret=myF1TSC->getFieldWithProfile(type,meshDimRelToMax,mesh,pfl,this,*contentNotNullBase());
9266 return MEDFileIntField1TS::ReturnSafelyDataArrayInt(ret);
9270 * Returns a new MEDFileIntField1TS holding data of a given time step of \a this field.
9271 * \param [in] pos - a time step id.
9272 * \return MEDFileIntField1TS * - a new instance of MEDFileIntField1TS. The caller is to
9273 * delete this field using decrRef() as it is no more needed.
9274 * \throw If \a pos is not a valid time step id.
9276 MEDFileAnyTypeField1TS *MEDFileIntFieldMultiTS::getTimeStepAtPos(int pos) const
9278 const MEDFileAnyTypeField1TSWithoutSDA *item=contentNotNullBase()->getTimeStepAtPos2(pos);
9281 std::ostringstream oss; oss << "MEDFileIntFieldMultiTS::getTimeStepAtPos : field at pos #" << pos << " is null !";
9282 throw INTERP_KERNEL::Exception(oss.str().c_str());
9284 const MEDFileIntField1TSWithoutSDA *itemC=dynamic_cast<const MEDFileIntField1TSWithoutSDA *>(item);
9287 MEDCouplingAutoRefCountObjectPtr<MEDFileIntField1TS> ret=MEDFileIntField1TS::New(*itemC,false);
9288 ret->shallowCpyGlobs(*this);
9291 std::ostringstream oss; oss << "MEDFileIntFieldMultiTS::getTimeStepAtPos : type of field at pos #" << pos << " is not INT32 !";
9292 throw INTERP_KERNEL::Exception(oss.str().c_str());
9296 * Adds a MEDCouplingFieldDouble to \a this as another time step. The underlying mesh of
9297 * the given field is checked if its elements are sorted suitable for writing to MED file
9298 * ("STB" stands for "Sort By Type"), if not, an exception is thrown.
9299 * For more info, see \ref AdvMEDLoaderAPIFieldRW
9300 * \param [in] field - the field to add to \a this.
9301 * \throw If the name of \a field is empty.
9302 * \throw If the data array of \a field is not set.
9303 * \throw If existing time steps have different name or number of components than \a field.
9304 * \throw If the underlying mesh of \a field has no name.
9305 * \throw If elements in the mesh are not in the order suitable for writing to the MED file.
9307 void MEDFileIntFieldMultiTS::appendFieldNoProfileSBT(const MEDCouplingFieldDouble *field, const DataArrayInt *arrOfVals)
9309 contentNotNull()->appendFieldNoProfileSBT(field,arrOfVals,*this);
9313 * Adds a MEDCouplingFieldDouble to \a this as another time step.
9314 * The mesh support of input parameter \a field is ignored here, it can be NULL.
9315 * The support of field \a field is expected to be those computed with the input parameter \a mesh, \a meshDimRelToMax,
9318 * This method will check that the field based on the computed support is coherent. If not an exception will be thrown.
9319 * A new profile is added only if no equal profile is missing.
9320 * For more info, see \ref AdvMEDLoaderAPIFieldRW
9321 * \param [in] field - the field to add to \a this. The field double values and mesh support are ignored.
9322 * \param [in] arrOfVals - the values of the field \a field used.
9323 * \param [in] mesh - the supporting mesh of \a field.
9324 * \param [in] meshDimRelToMax - a relative dimension of mesh entities \a field lies on (useless if field spatial discretization is ON_NODES).
9325 * \param [in] profile - ids of mesh entities on which corresponding field values lie.
9326 * \throw If either \a field or \a mesh or \a profile has an empty name.
9327 * \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a mesh.
9328 * \throw If the data array of \a field is not set.
9329 * \throw If the data array of \a this is already allocated but has different number of
9330 * components than \a field.
9331 * \throw If elements in \a mesh are not in the order suitable for writing to the MED file.
9332 * \sa setFieldNoProfileSBT()
9334 void MEDFileIntFieldMultiTS::appendFieldProfile(const MEDCouplingFieldDouble *field, const DataArrayInt *arrOfVals, const MEDFileMesh *mesh, int meshDimRelToMax, const DataArrayInt *profile)
9336 contentNotNull()->appendFieldProfile(field,arrOfVals,mesh,meshDimRelToMax,profile,*this);
9339 const MEDFileIntFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTS::contentNotNull() const
9341 const MEDFileAnyTypeFieldMultiTSWithoutSDA *pt(_content);
9343 throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::contentNotNull : the content pointer is null !");
9344 const MEDFileIntFieldMultiTSWithoutSDA *ret=dynamic_cast<const MEDFileIntFieldMultiTSWithoutSDA *>(pt);
9346 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 !");
9350 MEDFileIntFieldMultiTSWithoutSDA *MEDFileIntFieldMultiTS::contentNotNull()
9352 MEDFileAnyTypeFieldMultiTSWithoutSDA *pt(_content);
9354 throw INTERP_KERNEL::Exception("MEDFileIntFieldMultiTS::contentNotNull : the non const content pointer is null !");
9355 MEDFileIntFieldMultiTSWithoutSDA *ret=dynamic_cast<MEDFileIntFieldMultiTSWithoutSDA *>(pt);
9357 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 !");
9361 MEDFileIntFieldMultiTS::MEDFileIntFieldMultiTS()
9363 _content=new MEDFileIntFieldMultiTSWithoutSDA;
9366 MEDFileIntFieldMultiTS::MEDFileIntFieldMultiTS(const MEDFileIntFieldMultiTSWithoutSDA& other, bool shallowCopyOfContent):MEDFileAnyTypeFieldMultiTS(other,shallowCopyOfContent)
9370 MEDFileIntFieldMultiTS::MEDFileIntFieldMultiTS(const std::string& fileName, bool loadAll)
9371 try:MEDFileAnyTypeFieldMultiTS(fileName,loadAll)
9374 catch(INTERP_KERNEL::Exception& e)
9377 MEDFileIntFieldMultiTS::MEDFileIntFieldMultiTS(const std::string& fileName, const std::string& fieldName, bool loadAll)
9378 try:MEDFileAnyTypeFieldMultiTS(fileName,fieldName,loadAll)
9381 catch(INTERP_KERNEL::Exception& e)
9384 DataArrayInt *MEDFileIntFieldMultiTS::getUndergroundDataArray(int iteration, int order) const
9386 return static_cast<DataArrayInt *>(contentNotNull()->getUndergroundDataArray(iteration,order));
9391 MEDFileFields *MEDFileFields::New()
9393 return new MEDFileFields;
9396 MEDFileFields *MEDFileFields::New(const std::string& fileName, bool loadAll)
9398 return new MEDFileFields(fileName,loadAll);
9401 std::size_t MEDFileFields::getHeapMemorySizeWithoutChildren() const
9403 std::size_t ret(MEDFileFieldGlobsReal::getHeapMemorySizeWithoutChildren());
9404 ret+=_fields.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA>);
9408 std::vector<const BigMemoryObject *> MEDFileFields::getDirectChildren() const
9410 std::vector<const BigMemoryObject *> ret;
9411 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9413 const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur(*it);
9420 MEDFileFields *MEDFileFields::deepCpy() const
9422 MEDCouplingAutoRefCountObjectPtr<MEDFileFields> ret=shallowCpy();
9424 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
9426 if((const MEDFileAnyTypeFieldMultiTSWithoutSDA*)*it)
9427 ret->_fields[i]=(*it)->deepCpy();
9429 ret->deepCpyGlobs(*this);
9433 MEDFileFields *MEDFileFields::shallowCpy() const
9435 return new MEDFileFields(*this);
9439 * 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
9440 * 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.
9441 * If \a areThereSomeForgottenTS is set to true, only the sorted intersection of time steps present for all fields in \a this will be returned.
9443 * \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.
9444 * \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.
9446 * \sa MEDFileFields::partOfThisLyingOnSpecifiedTimeSteps, MEDFileFields::partOfThisNotLyingOnSpecifiedTimeSteps
9448 std::vector< std::pair<int,int> > MEDFileFields::getCommonIterations(bool& areThereSomeForgottenTS) const
9450 std::set< std::pair<int,int> > s;
9451 bool firstShot=true;
9452 areThereSomeForgottenTS=false;
9453 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9455 if(!(const MEDFileAnyTypeFieldMultiTSWithoutSDA*)*it)
9457 std::vector< std::pair<int,int> > v=(*it)->getIterations();
9458 std::set< std::pair<int,int> > s1; std::copy(v.begin(),v.end(),std::inserter(s1,s1.end()));
9460 { s=s1; firstShot=false; }
9463 std::set< std::pair<int,int> > s2; std::set_intersection(s.begin(),s.end(),s1.begin(),s1.end(),std::inserter(s2,s2.end()));
9465 areThereSomeForgottenTS=true;
9469 std::vector< std::pair<int,int> > ret;
9470 std::copy(s.begin(),s.end(),std::back_insert_iterator< std::vector< std::pair<int,int> > >(ret));
9474 int MEDFileFields::getNumberOfFields() const
9476 return _fields.size();
9479 std::vector<std::string> MEDFileFields::getFieldsNames() const
9481 std::vector<std::string> ret(_fields.size());
9483 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
9485 const MEDFileAnyTypeFieldMultiTSWithoutSDA *f=(*it);
9488 ret[i]=f->getName();
9492 std::ostringstream oss; oss << "MEDFileFields::getFieldsNames : At rank #" << i << " field is not defined !";
9493 throw INTERP_KERNEL::Exception(oss.str().c_str());
9499 std::vector<std::string> MEDFileFields::getMeshesNames() const
9501 std::vector<std::string> ret;
9502 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9504 const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur(*it);
9506 ret.push_back(cur->getMeshName());
9511 std::string MEDFileFields::simpleRepr() const
9513 std::ostringstream oss;
9514 oss << "(*****************)\n(* MEDFileFields *)\n(*****************)\n\n";
9519 void MEDFileFields::simpleRepr(int bkOffset, std::ostream& oss) const
9521 int nbOfFields=getNumberOfFields();
9522 std::string startLine(bkOffset,' ');
9523 oss << startLine << "There are " << nbOfFields << " fields in this :" << std::endl;
9525 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
9527 const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur=(*it);
9530 oss << startLine << " - # "<< i << " has the following name : \"" << cur->getName() << "\"." << std::endl;
9534 oss << startLine << " - not defined !" << std::endl;
9538 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
9540 const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur=(*it);
9541 std::string chapter(17,'0'+i);
9542 oss << startLine << chapter << std::endl;
9545 cur->simpleRepr(bkOffset+2,oss,i);
9549 oss << startLine << " - not defined !" << std::endl;
9551 oss << startLine << chapter << std::endl;
9553 simpleReprGlobs(oss);
9556 MEDFileFields::MEDFileFields()
9560 MEDFileFields::MEDFileFields(const std::string& fileName, bool loadAll)
9561 try:MEDFileFieldGlobsReal(fileName)
9563 MEDFileUtilities::CheckFileForRead(fileName);
9564 MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
9565 int nbFields=MEDnField(fid);
9566 _fields.resize(nbFields);
9567 med_field_type typcha;
9568 for(int i=0;i<nbFields;i++)
9570 std::vector<std::string> infos;
9571 std::string fieldName,dtunit;
9572 int nbOfStep=MEDFileAnyTypeField1TS::LocateField2(fid,fileName,i,false,fieldName,typcha,infos,dtunit);
9577 _fields[i]=MEDFileFieldMultiTSWithoutSDA::New(fid,fieldName.c_str(),typcha,infos,nbOfStep,dtunit,loadAll);
9582 _fields[i]=MEDFileIntFieldMultiTSWithoutSDA::New(fid,fieldName.c_str(),typcha,infos,nbOfStep,dtunit,loadAll);
9587 std::ostringstream oss; oss << "constructor MEDFileFields(fileName) : file \'" << fileName << "\' at pos #" << i << " field has name \'" << fieldName << "\' but the type of field is not in [MED_FLOAT64, MED_INT32] !";
9588 throw INTERP_KERNEL::Exception(oss.str().c_str());
9592 loadAllGlobals(fid);
9594 catch(INTERP_KERNEL::Exception& e)
9599 void MEDFileFields::writeLL(med_idt fid) const
9602 writeGlobals(fid,*this);
9603 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++,i++)
9605 const MEDFileAnyTypeFieldMultiTSWithoutSDA *elt=*it;
9608 std::ostringstream oss; oss << "MEDFileFields::write : at rank #" << i << "/" << _fields.size() << " field is empty !";
9609 throw INTERP_KERNEL::Exception(oss.str().c_str());
9611 elt->writeLL(fid,*this);
9615 void MEDFileFields::write(const std::string& fileName, int mode) const
9617 med_access_mode medmod=MEDFileUtilities::TraduceWriteMode(mode);
9618 MEDFileUtilities::AutoFid fid(MEDfileOpen(fileName.c_str(),medmod));
9623 * This method alloc the arrays and load potentially huge arrays contained in this field.
9624 * This method should be called when a MEDFileAnyTypeFieldMultiTS::New constructor has been with false as the last parameter.
9625 * This method can be also called to refresh or reinit values from a file.
9627 * \throw If the fileName is not set or points to a non readable MED file.
9629 void MEDFileFields::loadArrays()
9631 if(getFileName().empty())
9632 throw INTERP_KERNEL::Exception("MEDFileFields::loadArrays : the structure does not come from a file !");
9633 MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName().c_str(),MED_ACC_RDONLY);
9634 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
9636 MEDFileAnyTypeFieldMultiTSWithoutSDA *elt(*it);
9638 elt->loadBigArraysRecursively(fid,*elt);
9643 * This method behaves as MEDFileFields::loadArrays does, the first call, if \a this was built using a file without loading big arrays.
9644 * But once data loaded once, this method does nothing.
9646 * \throw If the fileName is not set or points to a non readable MED file.
9647 * \sa MEDFileFields::loadArrays, MEDFileFields::unloadArrays
9649 void MEDFileFields::loadArraysIfNecessary()
9651 if(!getFileName().empty())
9653 MEDFileUtilities::AutoFid fid=MEDfileOpen(getFileName().c_str(),MED_ACC_RDONLY);
9654 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
9656 MEDFileAnyTypeFieldMultiTSWithoutSDA *elt(*it);
9658 elt->loadBigArraysRecursivelyIfNecessary(fid,*elt);
9664 * This method releases potentially big data arrays and so returns to the same heap memory than status loaded with 'loadAll' parameter set to false.
9665 * \b WARNING, this method does release arrays even if \a this does not come from a load of a MED file.
9666 * So this method can lead to a loss of data. If you want to unload arrays safely call MEDFileFields::unloadArraysWithoutDataLoss instead.
9668 * \sa MEDFileFields::loadArrays, MEDFileFields::loadArraysIfNecessary, MEDFileFields::unloadArraysWithoutDataLoss
9670 void MEDFileFields::unloadArrays()
9672 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
9674 MEDFileAnyTypeFieldMultiTSWithoutSDA *elt(*it);
9676 elt->unloadArrays();
9681 * 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.
9682 * This method is the symetrical method of MEDFileFields::loadArraysIfNecessary.
9683 * This method is useful to reduce \b safely amount of heap memory necessary for \a this by using MED file as database.
9685 * \sa MEDFileFields::loadArraysIfNecessary
9687 void MEDFileFields::unloadArraysWithoutDataLoss()
9689 if(!getFileName().empty())
9693 std::vector<std::string> MEDFileFields::getPflsReallyUsed() const
9695 std::vector<std::string> ret;
9696 std::set<std::string> ret2;
9697 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9699 std::vector<std::string> tmp=(*it)->getPflsReallyUsed2();
9700 for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
9701 if(ret2.find(*it2)==ret2.end())
9703 ret.push_back(*it2);
9710 std::vector<std::string> MEDFileFields::getLocsReallyUsed() const
9712 std::vector<std::string> ret;
9713 std::set<std::string> ret2;
9714 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9716 std::vector<std::string> tmp=(*it)->getLocsReallyUsed2();
9717 for(std::vector<std::string>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
9718 if(ret2.find(*it2)==ret2.end())
9720 ret.push_back(*it2);
9727 std::vector<std::string> MEDFileFields::getPflsReallyUsedMulti() const
9729 std::vector<std::string> ret;
9730 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9732 std::vector<std::string> tmp=(*it)->getPflsReallyUsedMulti2();
9733 ret.insert(ret.end(),tmp.begin(),tmp.end());
9738 std::vector<std::string> MEDFileFields::getLocsReallyUsedMulti() const
9740 std::vector<std::string> ret;
9741 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9743 std::vector<std::string> tmp=(*it)->getLocsReallyUsed2();
9744 ret.insert(ret.end(),tmp.begin(),tmp.end());
9749 void MEDFileFields::changePflsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
9751 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::iterator it=_fields.begin();it!=_fields.end();it++)
9752 (*it)->changePflsRefsNamesGen2(mapOfModif);
9755 void MEDFileFields::changeLocsRefsNamesGen(const std::vector< std::pair<std::vector<std::string>, std::string > >& mapOfModif)
9757 for(std::vector< MEDCouplingAutoRefCountObjectPtr< MEDFileAnyTypeFieldMultiTSWithoutSDA > >::iterator it=_fields.begin();it!=_fields.end();it++)
9758 (*it)->changeLocsRefsNamesGen2(mapOfModif);
9761 void MEDFileFields::resize(int newSize)
9763 _fields.resize(newSize);
9766 void MEDFileFields::pushFields(const std::vector<MEDFileAnyTypeFieldMultiTS *>& fields)
9768 for(std::vector<MEDFileAnyTypeFieldMultiTS *>::const_iterator it=fields.begin();it!=fields.end();it++)
9772 void MEDFileFields::pushField(MEDFileAnyTypeFieldMultiTS *field)
9775 throw INTERP_KERNEL::Exception("MEDFileFields::pushMesh : invalid input pointer ! should be different from 0 !");
9776 _fields.push_back(field->getContent());
9777 appendGlobs(*field,1e-12);
9780 void MEDFileFields::setFieldAtPos(int i, MEDFileAnyTypeFieldMultiTS *field)
9783 throw INTERP_KERNEL::Exception("MEDFileFields::setFieldAtPos : invalid input pointer ! should be different from 0 !");
9784 if(i>=(int)_fields.size())
9785 _fields.resize(i+1);
9786 _fields[i]=field->getContent();
9787 appendGlobs(*field,1e-12);
9790 void MEDFileFields::destroyFieldAtPos(int i)
9792 destroyFieldsAtPos(&i,&i+1);
9795 void MEDFileFields::destroyFieldsAtPos(const int *startIds, const int *endIds)
9797 std::vector<bool> b(_fields.size(),true);
9798 for(const int *i=startIds;i!=endIds;i++)
9800 if(*i<0 || *i>=(int)_fields.size())
9802 std::ostringstream oss; oss << "MEDFileFields::destroyFieldsAtPos : Invalid given id in input (" << *i << ") should be in [0," << _fields.size() << ") !";
9803 throw INTERP_KERNEL::Exception(oss.str().c_str());
9807 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > fields(std::count(b.begin(),b.end(),true));
9809 for(std::size_t i=0;i<_fields.size();i++)
9811 fields[j++]=_fields[i];
9815 void MEDFileFields::destroyFieldsAtPos2(int bg, int end, int step)
9817 static const char msg[]="MEDFileFields::destroyFieldsAtPos2";
9818 int nbOfEntriesToKill=DataArrayInt::GetNumberOfItemGivenBESRelative(bg,end,step,msg);
9819 std::vector<bool> b(_fields.size(),true);
9821 for(int i=0;i<nbOfEntriesToKill;i++,k+=step)
9823 if(k<0 || k>=(int)_fields.size())
9825 std::ostringstream oss; oss << "MEDFileFields::destroyFieldsAtPos2 : Invalid given id in input (" << k << ") should be in [0," << _fields.size() << ") !";
9826 throw INTERP_KERNEL::Exception(oss.str().c_str());
9830 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > fields(std::count(b.begin(),b.end(),true));
9832 for(std::size_t i=0;i<_fields.size();i++)
9834 fields[j++]=_fields[i];
9838 bool MEDFileFields::changeMeshNames(const std::vector< std::pair<std::string,std::string> >& modifTab)
9841 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
9843 MEDFileAnyTypeFieldMultiTSWithoutSDA *cur(*it);
9845 ret=cur->changeMeshNames(modifTab) || ret;
9851 * \param [in] meshName the name of the mesh that will be renumbered.
9852 * \param [in] oldCode is of format returned by MEDCouplingUMesh::getDistributionOfTypes. And for each *i* oldCode[3*i+2] gives the position (MEDFileUMesh::PutInThirdComponentOfCodeOffset).
9853 * This code corresponds to the distribution of types in the corresponding mesh.
9854 * \param [in] newCode idem to param \a oldCode except that here the new distribution is given.
9855 * \param [in] renumO2N the old to new renumber array.
9856 * \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
9859 bool MEDFileFields::renumberEntitiesLyingOnMesh(const std::string& meshName, const std::vector<int>& oldCode, const std::vector<int>& newCode, const DataArrayInt *renumO2N)
9862 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::iterator it=_fields.begin();it!=_fields.end();it++)
9864 MEDFileAnyTypeFieldMultiTSWithoutSDA *fmts(*it);
9867 ret=fmts->renumberEntitiesLyingOnMesh(meshName,oldCode,newCode,renumO2N,*this) || ret;
9873 MEDFileAnyTypeFieldMultiTS *MEDFileFields::getFieldAtPos(int i) const
9875 if(i<0 || i>=(int)_fields.size())
9877 std::ostringstream oss; oss << "MEDFileFields::getFieldAtPos : Invalid given id in input (" << i << ") should be in [0," << _fields.size() << ") !";
9878 throw INTERP_KERNEL::Exception(oss.str().c_str());
9880 const MEDFileAnyTypeFieldMultiTSWithoutSDA *fmts=_fields[i];
9883 MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTS> ret;
9884 const MEDFileFieldMultiTSWithoutSDA *fmtsC=dynamic_cast<const MEDFileFieldMultiTSWithoutSDA *>(fmts);
9885 const MEDFileIntFieldMultiTSWithoutSDA *fmtsC2=dynamic_cast<const MEDFileIntFieldMultiTSWithoutSDA *>(fmts);
9887 ret=MEDFileFieldMultiTS::New(*fmtsC,false);
9889 ret=MEDFileIntFieldMultiTS::New(*fmtsC2,false);
9892 std::ostringstream oss; oss << "MEDFileFields::getFieldAtPos : At pos #" << i << " field is neither double (FLOAT64) nor integer (INT32) !";
9893 throw INTERP_KERNEL::Exception(oss.str().c_str());
9895 ret->shallowCpyGlobs(*this);
9900 * Return a shallow copy of \a this reduced to the fields ids defined in [ \a startIds , endIds ).
9901 * This method is accessible in python using __getitem__ with a list in input.
9902 * \return a new object that the caller should deal with.
9904 MEDFileFields *MEDFileFields::buildSubPart(const int *startIds, const int *endIds) const
9906 MEDCouplingAutoRefCountObjectPtr<MEDFileFields> ret=shallowCpy();
9907 std::size_t sz=std::distance(startIds,endIds);
9908 std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > fields(sz);
9910 for(const int *i=startIds;i!=endIds;i++,j++)
9912 if(*i<0 || *i>=(int)_fields.size())
9914 std::ostringstream oss; oss << "MEDFileFields::buildSubPart : Invalid given id in input (" << *i << ") should be in [0," << _fields.size() << ") !";
9915 throw INTERP_KERNEL::Exception(oss.str().c_str());
9917 fields[j]=_fields[*i];
9919 ret->_fields=fields;
9923 MEDFileAnyTypeFieldMultiTS *MEDFileFields::getFieldWithName(const std::string& fieldName) const
9925 return getFieldAtPos(getPosFromFieldName(fieldName));
9929 * This method removes, if any, fields in \a this having no time steps.
9930 * 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.
9932 * If false is returned \a this does not contain such fields. If false is returned this method can be considered as const.
9934 bool MEDFileFields::removeFieldsWithoutAnyTimeStep()
9936 std::vector<MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> > newFields;
9937 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9939 const MEDFileAnyTypeFieldMultiTSWithoutSDA *elt(*it);
9942 if(elt->getNumberOfTS()>0)
9943 newFields.push_back(*it);
9946 if(_fields.size()==newFields.size())
9953 * This method returns a new object containing part of \a this fields lying on mesh name specified by the input parameter \a meshName.
9954 * This method can be seen as a filter applied on \a this, that returns an object containing
9955 * 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
9956 * shallow copied from \a this.
9958 * \param [in] meshName - the name of the mesh on w
9959 * \return a new object that the caller should deal with.
9961 MEDFileFields *MEDFileFields::partOfThisLyingOnSpecifiedMeshName(const std::string& meshName) const
9963 MEDCouplingAutoRefCountObjectPtr<MEDFileFields> ret=MEDFileFields::New();
9964 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9966 const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur=(*it);
9969 if(cur->getMeshName()==meshName)
9972 MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> cur2(const_cast<MEDFileAnyTypeFieldMultiTSWithoutSDA *>(cur));
9973 ret->_fields.push_back(cur2);
9976 ret->shallowCpyOnlyUsedGlobs(*this);
9981 * This method returns a new object containing part of \a this fields lying ** exactly ** on the time steps specified by input parameter \a timeSteps.
9982 * Input time steps are specified using a pair of integer (iteration, order).
9983 * 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,
9984 * but for each multitimestep only the time steps in \a timeSteps are kept.
9985 * Typically the input parameter \a timeSteps comes from the call of MEDFileFields::getCommonIterations.
9987 * The returned object points to shallow copy of elements in \a this.
9989 * \param [in] timeSteps - the time steps given by a vector of pair of integers (iteration,order)
9990 * \throw If there is a field in \a this that is \b not defined on a time step in the input \a timeSteps.
9991 * \sa MEDFileFields::getCommonIterations, MEDFileFields::partOfThisNotLyingOnSpecifiedTimeSteps
9993 MEDFileFields *MEDFileFields::partOfThisLyingOnSpecifiedTimeSteps(const std::vector< std::pair<int,int> >& timeSteps) const
9995 MEDCouplingAutoRefCountObjectPtr<MEDFileFields> ret=MEDFileFields::New();
9996 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
9998 const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur=(*it);
10001 MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> elt=cur->partOfThisLyingOnSpecifiedTimeSteps(timeSteps);
10002 ret->_fields.push_back(elt);
10004 ret->shallowCpyOnlyUsedGlobs(*this);
10009 * \sa MEDFileFields::getCommonIterations, MEDFileFields::partOfThisLyingOnSpecifiedTimeSteps
10011 MEDFileFields *MEDFileFields::partOfThisNotLyingOnSpecifiedTimeSteps(const std::vector< std::pair<int,int> >& timeSteps) const
10013 MEDCouplingAutoRefCountObjectPtr<MEDFileFields> ret=MEDFileFields::New();
10014 for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> >::const_iterator it=_fields.begin();it!=_fields.end();it++)
10016 const MEDFileAnyTypeFieldMultiTSWithoutSDA *cur=(*it);
10019 MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeFieldMultiTSWithoutSDA> elt=cur->partOfThisNotLyingOnSpecifiedTimeSteps(timeSteps);
10020 if(elt->getNumberOfTS()!=0)
10021 ret->_fields.push_back(elt);
10023 ret->shallowCpyOnlyUsedGlobs(*this);
10027 MEDFileFieldsIterator *MEDFileFields::iterator()
10029 return new MEDFileFieldsIterator(this);
10032 int MEDFileFields::getPosFromFieldName(const std::string& fieldName) const
10034 std::string tmp(fieldName);
10035 std::vector<std::string> poss;
10036 for(std::size_t i=0;i<_fields.size();i++)
10038 const MEDFileAnyTypeFieldMultiTSWithoutSDA *f=_fields[i];
10041 std::string fname(f->getName());
10045 poss.push_back(fname);
10048 std::ostringstream oss; oss << "MEDFileFields::getPosFromFieldName : impossible to find field '" << tmp << "' in this ! Possibilities are : ";
10049 std::copy(poss.begin(),poss.end(),std::ostream_iterator<std::string>(oss,", "));
10051 throw INTERP_KERNEL::Exception(oss.str().c_str());
10054 MEDFileFieldsIterator::MEDFileFieldsIterator(MEDFileFields *fs):_fs(fs),_iter_id(0),_nb_iter(0)
10059 _nb_iter=fs->getNumberOfFields();
10063 MEDFileFieldsIterator::~MEDFileFieldsIterator()
10067 MEDFileAnyTypeFieldMultiTS *MEDFileFieldsIterator::nextt()
10069 if(_iter_id<_nb_iter)
10071 MEDFileFields *fs(_fs);
10073 return fs->getFieldAtPos(_iter_id++);