1 // Copyright (C) 2007-2023 CEA/DEN, EDF R&D
3 // This library is free software; you can redistribute it and/or
4 // modify it under the terms of the GNU Lesser General Public
5 // License as published by the Free Software Foundation; either
6 // version 2.1 of the License, or (at your option) any later version.
8 // This library is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 // Lesser General Public License for more details.
13 // You should have received a copy of the GNU Lesser General Public
14 // License along with this library; if not, write to the Free Software
15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
19 // Author : Anthony Geay (EDF R&D)
21 #include "MEDCouplingIMesh.hxx"
22 #include "MEDCouplingCMesh.hxx"
23 #include "MEDCouplingMemArray.hxx"
24 #include "MEDCouplingFieldDouble.hxx"
31 using namespace MEDCoupling;
33 MEDCouplingIMesh::MEDCouplingIMesh():_space_dim(-1)
35 _origin[0]=0.; _origin[1]=0.; _origin[2]=0.;
36 _dxyz[0]=0.; _dxyz[1]=0.; _dxyz[2]=0.;
37 _structure[0]=0; _structure[1]=0; _structure[2]=0;
40 MEDCouplingIMesh::MEDCouplingIMesh(const MEDCouplingIMesh& other, bool deepCpy):MEDCouplingStructuredMesh(other,deepCpy),_space_dim(other._space_dim),_axis_unit(other._axis_unit)
42 _origin[0]=other._origin[0]; _origin[1]=other._origin[1]; _origin[2]=other._origin[2];
43 _dxyz[0]=other._dxyz[0]; _dxyz[1]=other._dxyz[1]; _dxyz[2]=other._dxyz[2];
44 _structure[0]=other._structure[0]; _structure[1]=other._structure[1]; _structure[2]=other._structure[2];
47 MEDCouplingIMesh::~MEDCouplingIMesh()
51 MEDCouplingIMesh *MEDCouplingIMesh::New()
53 return new MEDCouplingIMesh;
56 MEDCouplingIMesh *MEDCouplingIMesh::New(const std::string& meshName, int spaceDim, const mcIdType *nodeStrctStart, const mcIdType *nodeStrctStop,
57 const double *originStart, const double *originStop, const double *dxyzStart, const double *dxyzStop)
59 MCAuto<MEDCouplingIMesh> ret(new MEDCouplingIMesh);
60 ret->setName(meshName);
61 ret->setSpaceDimension(spaceDim);
62 ret->setNodeStruct(nodeStrctStart,nodeStrctStop);
63 ret->setOrigin(originStart,originStop);
64 ret->setDXYZ(dxyzStart,dxyzStop);
68 MEDCouplingIMesh *MEDCouplingIMesh::deepCopy() const
73 MEDCouplingIMesh *MEDCouplingIMesh::clone(bool recDeepCpy) const
75 return new MEDCouplingIMesh(*this,recDeepCpy);
78 const DataArrayDouble *MEDCouplingIMesh::getDirectAccessOfCoordsArrIfInStructure() const
80 throw INTERP_KERNEL::Exception("MEDCouplingIMesh::getDirectAccessOfCoordsArrIfInStructure : MEDCouplingIMesh does not aggregate array of coordinates !");
84 * This method creates a copy of \a this enlarged by \a ghostLev cells on each axis.
85 * If \a ghostLev equal to 0 this method behaves as MEDCouplingIMesh::clone.
87 * \param [in] ghostLev - the ghost level expected
88 * \return MEDCouplingIMesh * - a newly alloacted object to be managed by the caller.
89 * \throw if \a ghostLev < 0.
91 MEDCouplingIMesh *MEDCouplingIMesh::buildWithGhost(mcIdType ghostLev) const
94 throw INTERP_KERNEL::Exception("MEDCouplingIMesh::buildWithGhost : the ghostLev must be >= 0 !");
95 checkConsistencyLight();
96 int spaceDim(getSpaceDimension());
97 double origin[3],dxyz[3];
98 mcIdType structure[3];
99 for(int i=0;i<spaceDim;i++)
101 origin[i]=_origin[i]-FromIdType<double>(ghostLev)*_dxyz[i];
103 structure[i]=_structure[i]+2*ghostLev;
105 MCAuto<MEDCouplingIMesh> ret(MEDCouplingIMesh::New(getName(),spaceDim,structure,structure+spaceDim,origin,origin+spaceDim,dxyz,dxyz+spaceDim));
106 ret->copyTinyInfoFrom(this);
110 void MEDCouplingIMesh::setNodeStruct(const mcIdType *nodeStrctStart, const mcIdType *nodeStrctStop)
112 checkSpaceDimension();
113 mcIdType sz((mcIdType)std::distance(nodeStrctStart,nodeStrctStop));
115 throw INTERP_KERNEL::Exception("MEDCouplingIMesh::setNodeStruct : input vector of node structure has not the right size ! Or change space dimension before calling it !");
116 std::copy(nodeStrctStart,nodeStrctStop,_structure);
120 std::vector<mcIdType> MEDCouplingIMesh::getNodeStruct() const
122 checkSpaceDimension();
123 return std::vector<mcIdType>(_structure,_structure+_space_dim);
126 void MEDCouplingIMesh::setOrigin(const double *originStart, const double *originStop)
128 checkSpaceDimension();
129 mcIdType sz(ToIdType(std::distance(originStart,originStop)));
131 throw INTERP_KERNEL::Exception("MEDCouplingIMesh::setOrigin : input vector of origin vector has not the right size ! Or change space dimension before calling it !");
132 std::copy(originStart,originStop,_origin);
136 std::vector<double> MEDCouplingIMesh::getOrigin() const
138 checkSpaceDimension();
139 return std::vector<double>(_origin,_origin+_space_dim);
142 void MEDCouplingIMesh::setDXYZ(const double *dxyzStart, const double *dxyzStop)
144 checkSpaceDimension();
145 mcIdType sz(ToIdType(std::distance(dxyzStart,dxyzStop)));
147 throw INTERP_KERNEL::Exception("MEDCouplingIMesh::setDXYZ : input vector of dxyz vector has not the right size ! Or change space dimension before calling it !");
148 std::copy(dxyzStart,dxyzStop,_dxyz);
152 std::vector<double> MEDCouplingIMesh::getDXYZ() const
154 checkSpaceDimension();
155 return std::vector<double>(_dxyz,_dxyz+_space_dim);
158 void MEDCouplingIMesh::setAxisUnit(const std::string& unitName)
164 std::string MEDCouplingIMesh::getAxisUnit() const
170 * This method returns the measure of any cell in \a this.
171 * This specific method of image grid mesh utilizes the fact that any cell in \a this have the same measure.
172 * The value returned by this method is those used to feed the returned field in the MEDCouplingIMesh::getMeasureField.
174 * \sa getMeasureField
176 double MEDCouplingIMesh::getMeasureOfAnyCell() const
178 checkConsistencyLight();
179 int dim(getSpaceDimension());
181 for(int i=0;i<dim;i++)
187 * This method is allows to convert \a this into MEDCouplingCMesh instance.
188 * This method is the middle level between MEDCouplingIMesh and the most general MEDCouplingUMesh.
189 * This method is useful for MED writers that do not have still the image grid support.
191 * \sa MEDCouplingMesh::buildUnstructured
193 MEDCouplingCMesh *MEDCouplingIMesh::convertToCartesian() const
195 checkConsistencyLight();
196 MCAuto<MEDCouplingCMesh> ret(MEDCouplingCMesh::New());
198 { ret->copyTinyInfoFrom(this); }
199 catch(INTERP_KERNEL::Exception& ) { }
200 int spaceDim(getSpaceDimension());
201 std::vector<std::string> infos(buildInfoOnComponents());
202 for(int i=0;i<spaceDim;i++)
204 MCAuto<DataArrayDouble> arr(DataArrayDouble::New()); arr->alloc(_structure[i],1); arr->setInfoOnComponent(0,infos[i]);
205 arr->iota(); arr->applyLin(_dxyz[i],_origin[i]);
206 ret->setCoordsAt(i,arr);
212 * This method refines \a this uniformaly along all of its dimensions. In case of success the space covered by \a this will remain
213 * the same before the invocation except that the number of cells will be multiplied by \a factor ^ this->getMeshDimension().
214 * The origin of \a this will be not touched only spacing and node structure will be changed.
215 * This method can be useful for AMR users.
217 void MEDCouplingIMesh::refineWithFactor(const std::vector<mcIdType>& factors)
219 if(ToIdType(factors.size())!=_space_dim)
220 throw INTERP_KERNEL::Exception("MEDCouplingIMesh::refineWithFactor : refinement factors must have size equal to spaceDim !");
221 checkConsistencyLight();
222 std::vector<mcIdType> structure(_structure,_structure+3);
223 std::vector<double> dxyz(_dxyz,_dxyz+3);
224 for(int i=0;i<_space_dim;i++)
228 std::ostringstream oss; oss << "MEDCouplingIMesh::refineWithFactor : factor for axis #" << i << " (" << factors[i] << ")is invalid ! Must be > 0 !";
229 throw INTERP_KERNEL::Exception(oss.str().c_str());
231 mcIdType factAbs(std::abs(factors[i]));
232 double fact2(1./(double)factors[i]);
233 structure[i]=(_structure[i]-1)*factAbs+1;
234 dxyz[i]=fact2*_dxyz[i];
236 std::copy(structure.begin(),structure.end(),_structure);
237 std::copy(dxyz.begin(),dxyz.end(),_dxyz);
242 * This method returns a newly created mesh containing a single cell in it. This returned cell covers exactly the space covered by \a this.
244 * \return MEDCouplingIMesh * - A newly created object (to be managed by the caller with decrRef) containing simply one cell.
246 * \throw if \a this does not pass the \c checkConsistencyLight test.
248 MEDCouplingIMesh *MEDCouplingIMesh::asSingleCell() const
250 checkConsistencyLight();
251 mcIdType spaceDim(getSpaceDimension()),nodeSt[3];
253 for(int i=0;i<spaceDim;i++)
258 dxyz[i]=double(_structure[i]-1)*_dxyz[i];
262 nodeSt[i]=_structure[i];
266 MCAuto<MEDCouplingIMesh> ret(MEDCouplingIMesh::New(getName(),getSpaceDimension(),nodeSt,nodeSt+spaceDim,_origin,_origin+spaceDim,dxyz,dxyz+spaceDim));
267 ret->copyTinyInfoFrom(this);
272 * This static method is useful to condense field on cells of a MEDCouplingIMesh instance coming from a refinement ( MEDCouplingIMesh::refineWithFactor for example)
273 * to a coarse MEDCouplingIMesh instance. So this method can be seen as a specialization in P0P0 conservative interpolation non overlapping from fine image mesh
274 * to a coarse image mesh. Only tuples ( deduced from \a fineLocInCoarse ) of \a coarseDA will be modified. Other tuples of \a coarseDA will be let unchanged.
276 * \param [in] coarseSt The cell structure of coarse mesh.
277 * \param [in] fineDA The DataArray containing the cell field on uniformly refined mesh
278 * \param [in] fineLocInCoarse The cell localization of refined mesh into the coarse one.
279 * \param [in] facts The refinement coefficient per axis.
280 * \param [in,out] coarseDA The DataArrayDouble corresponding to the a cell field of a coarse mesh whose cell structure is defined by \a coarseSt.
282 * \sa CondenseFineToCoarseGhost,SpreadCoarseToFine
284 void MEDCouplingIMesh::CondenseFineToCoarse(const std::vector<mcIdType>& coarseSt, const DataArrayDouble *fineDA, const std::vector< std::pair<mcIdType,mcIdType> >& fineLocInCoarse, const std::vector<mcIdType>& facts, DataArrayDouble *coarseDA)
286 if(coarseSt.size()!=fineLocInCoarse.size() || coarseSt.size()!=facts.size())
287 throw INTERP_KERNEL::Exception("MEDCouplingIMesh::CondenseFineToCoarse : All input vectors (dimension) must have the same size !");
288 if(!coarseDA || !coarseDA->isAllocated() || !fineDA || !fineDA->isAllocated())
289 throw INTERP_KERNEL::Exception("MEDCouplingIMesh::CondenseFineToCoarse : the parameters 1 or 3 are NULL or not allocated !");
290 std::size_t meshDim(coarseSt.size());
291 mcIdType nbOfTuplesInCoarseExp(MEDCouplingStructuredMesh::DeduceNumberOfGivenStructure(coarseSt)),nbOfTuplesInFineExp(MEDCouplingStructuredMesh::DeduceNumberOfGivenRangeInCompactFrmt(fineLocInCoarse));
292 std::size_t nbCompo=fineDA->getNumberOfComponents();
293 if(coarseDA->getNumberOfComponents()!=nbCompo)
294 throw INTERP_KERNEL::Exception("MEDCouplingIMesh::CondenseFineToCoarse : the number of components of fine DA and coarse one mismatches !");
295 if(meshDim!=fineLocInCoarse.size() || meshDim!=facts.size())
296 throw INTERP_KERNEL::Exception("MEDCouplingIMesh::CondenseFineToCoarse : the size of fineLocInCoarse (4th param) and facts (5th param) must be equal to the sier of coarseSt (2nd param) !");
297 if(coarseDA->getNumberOfTuples()!=nbOfTuplesInCoarseExp)
299 std::ostringstream oss; oss << "MEDCouplingIMesh::CondenseFineToCoarse : Expecting " << nbOfTuplesInCoarseExp << " tuples having " << coarseDA->getNumberOfTuples() << " !";
300 throw INTERP_KERNEL::Exception(oss.str().c_str());
302 mcIdType nbTuplesFine(fineDA->getNumberOfTuples());
303 if(nbOfTuplesInFineExp==0)
308 throw INTERP_KERNEL::Exception("MEDCouplingIMesh::CondenseFineToCoarse : Nothing to condense considering the range specified ! But DataArray is not empty !");
310 if(nbTuplesFine%nbOfTuplesInFineExp!=0)
311 throw INTERP_KERNEL::Exception("MEDCouplingIMesh::CondenseFineToCoarse : Invalid nb of tuples in fine DataArray regarding its structure !");
312 mcIdType fact(std::accumulate(facts.begin(),facts.end(),1,std::multiplies<mcIdType>()));
313 if(nbTuplesFine!=fact*nbOfTuplesInFineExp)
315 std::ostringstream oss; oss << "MEDCouplingIMesh::CondenseFineToCoarse : Invalid number of tuples (" << nbTuplesFine << ") of fine dataarray is invalid ! Must be " << fact*nbOfTuplesInFineExp << "!";
316 throw INTERP_KERNEL::Exception(oss.str().c_str());
318 // to improve use jump-iterator. Factorizes with SwitchOnIdsFrom BuildExplicitIdsFrom
319 double *outPtr(coarseDA->getPointer());
320 const double *inPtr(fineDA->begin());
322 std::vector<mcIdType> dims(MEDCouplingStructuredMesh::GetDimensionsFromCompactFrmt(fineLocInCoarse));
327 mcIdType offset(fineLocInCoarse[0].first),fact0(facts[0]);
328 for(int i=0;i<dims[0];i++)
330 double *loc(outPtr+(offset+i)*nbCompo);
331 for(mcIdType ifact=0;ifact<fact0;ifact++,inPtr+=nbCompo)
334 std::transform(inPtr,inPtr+nbCompo,loc,loc,std::plus<double>());
336 std::copy(inPtr,inPtr+nbCompo,loc);
343 mcIdType kk(fineLocInCoarse[0].first+coarseSt[0]*fineLocInCoarse[1].first),fact1(facts[1]),fact0(facts[0]);
344 for(int j=0;j<dims[1];j++)
346 for(mcIdType jfact=0;jfact<fact1;jfact++)
348 for(int i=0;i<dims[0];i++)
350 double *loc(outPtr+(kk+i)*nbCompo);
351 for(mcIdType ifact=0;ifact<fact0;ifact++,inPtr+=nbCompo)
353 if(jfact!=0 || ifact!=0)
354 std::transform(inPtr,inPtr+nbCompo,loc,loc,std::plus<double>());
356 std::copy(inPtr,inPtr+nbCompo,loc);
366 mcIdType kk(fineLocInCoarse[0].first+coarseSt[0]*fineLocInCoarse[1].first+coarseSt[0]*coarseSt[1]*fineLocInCoarse[2].first),fact2(facts[2]),fact1(facts[1]),fact0(facts[0]);
367 for(int k=0;k<dims[2];k++)
369 for(mcIdType kfact=0;kfact<fact2;kfact++)
371 for(int j=0;j<dims[1];j++)
373 for(mcIdType jfact=0;jfact<fact1;jfact++)
375 for(int i=0;i<dims[0];i++)
377 double *loc(outPtr+(kk+i+j*coarseSt[0])*nbCompo);
378 for(mcIdType ifact=0;ifact<fact0;ifact++,inPtr+=nbCompo)
380 if(kfact!=0 || jfact!=0 || ifact!=0)
381 std::transform(inPtr,inPtr+nbCompo,loc,loc,std::plus<double>());
383 std::copy(inPtr,inPtr+nbCompo,loc);
389 kk+=coarseSt[0]*coarseSt[1];
394 throw INTERP_KERNEL::Exception("MEDCouplingIMesh::CondenseFineToCoarse : only dimensions 1, 2 and 3 supported !");
399 * This static method is useful to condense field on cells of a MEDCouplingIMesh instance coming from a refinement ( MEDCouplingIMesh::refineWithFactor for example)
400 * to a coarse MEDCouplingIMesh instance. So this method can be seen as a specialization in P0P0 conservative interpolation non overlapping from fine image mesh
401 * to a coarse image mesh. Only tuples ( deduced from \a fineLocInCoarse ) of \a coarseDA will be modified. Other tuples of \a coarseDA will be let unchanged.
403 * \param [in] coarseSt The cell structure of coarse mesh.
404 * \param [in] fineDA The DataArray containing the cell field on uniformly refined mesh
405 * \param [in] fineLocInCoarse The cell localization of refined mesh into the coarse one.
406 * \param [in] facts The refinement coefficient per axis.
407 * \param [in,out] coarseDA The DataArrayDouble corresponding to the a cell field of a coarse mesh whose cell structure is defined by \a coarseSt.
408 * \param [in] ghostSize - The size of the ghost zone. The ghost zone is expected to be the same for all axis and both for coarse and fine meshes.
410 * \sa CondenseFineToCoarse,SpreadCoarseToFineGhost
412 void MEDCouplingIMesh::CondenseFineToCoarseGhost(const std::vector<mcIdType>& coarseSt, const DataArrayDouble *fineDA, const std::vector< std::pair<mcIdType,mcIdType> >& fineLocInCoarse, const std::vector<mcIdType>& facts, DataArrayDouble *coarseDA, mcIdType ghostSize)
415 throw INTERP_KERNEL::Exception("MEDCouplingIMesh::CondenseFineToCoarseGhost : ghost level has to be >= 0 !");
416 if(coarseSt.size()!=fineLocInCoarse.size() || coarseSt.size()!=facts.size())
417 throw INTERP_KERNEL::Exception("MEDCouplingIMesh::CondenseFineToCoarseGhost : All input vectors (dimension) must have the same size !");
418 if(!coarseDA || !coarseDA->isAllocated() || !fineDA || !fineDA->isAllocated())
419 throw INTERP_KERNEL::Exception("MEDCouplingIMesh::CondenseFineToCoarseGhost : the parameters 1 or 3 are NULL or not allocated !");
420 std::vector<mcIdType> coarseStG(coarseSt.size()); std::transform(coarseSt.begin(),coarseSt.end(),coarseStG.begin(),std::bind(std::plus<mcIdType>(),std::placeholders::_1,2*ghostSize));
421 std::size_t meshDim(coarseSt.size());
422 mcIdType nbOfTuplesInCoarseExp(MEDCouplingStructuredMesh::DeduceNumberOfGivenStructure(coarseStG));
423 std::size_t nbCompo(fineDA->getNumberOfComponents());
424 if(coarseDA->getNumberOfComponents()!=nbCompo)
425 throw INTERP_KERNEL::Exception("MEDCouplingIMesh::CondenseFineToCoarseGhost : the number of components of fine DA and coarse one mismatches !");
426 if(meshDim!=fineLocInCoarse.size() || meshDim!=facts.size())
427 throw INTERP_KERNEL::Exception("MEDCouplingIMesh::CondenseFineToCoarseGhost : the size of fineLocInCoarse (4th param) and facts (5th param) must be equal to the sier of coarseSt (2nd param) !");
428 if(coarseDA->getNumberOfTuples()!=nbOfTuplesInCoarseExp)
430 std::ostringstream oss; oss << "MEDCouplingIMesh::CondenseFineToCoarseGhost : Expecting " << nbOfTuplesInCoarseExp << " tuples in coarse DataArray having " << coarseDA->getNumberOfTuples() << " !";
431 throw INTERP_KERNEL::Exception(oss.str().c_str());
434 std::vector<mcIdType> fineStG(MEDCouplingStructuredMesh::GetDimensionsFromCompactFrmt(fineLocInCoarse));
435 std::transform(fineStG.begin(),fineStG.end(),facts.begin(),fineStG.begin(),std::multiplies<mcIdType>());
436 std::transform(fineStG.begin(),fineStG.end(),fineStG.begin(),std::bind(std::plus<mcIdType>(),std::placeholders::_1,2*ghostSize));
437 mcIdType nbTuplesFine(fineDA->getNumberOfTuples()),nbTuplesFineExp(MEDCouplingStructuredMesh::DeduceNumberOfGivenStructure(fineStG));
438 if(fineDA->getNumberOfTuples()!=nbTuplesFineExp)
440 std::ostringstream oss; oss << "MEDCouplingIMesh::CondenseFineToCoarseGhost : Expecting " << nbTuplesFineExp << " tuples in fine DataArray having " << nbTuplesFine << " !";
441 throw INTERP_KERNEL::Exception(oss.str().c_str());
444 double *outPtr(coarseDA->getPointer());
445 const double *inPtr(fineDA->begin());
447 std::vector<mcIdType> dims(MEDCouplingStructuredMesh::GetDimensionsFromCompactFrmt(fineLocInCoarse));
452 mcIdType offset(fineLocInCoarse[0].first+ghostSize),fact0(facts[0]);
453 inPtr+=ghostSize*nbCompo;
454 for(int i=0;i<dims[0];i++)
456 double *loc(outPtr+(offset+i)*nbCompo);
457 for(mcIdType ifact=0;ifact<fact0;ifact++,inPtr+=nbCompo)
460 std::transform(inPtr,inPtr+nbCompo,loc,loc,std::plus<double>());
462 std::copy(inPtr,inPtr+nbCompo,loc);
469 mcIdType nxwg(coarseSt[0]+2*ghostSize);
470 mcIdType kk(fineLocInCoarse[0].first+ghostSize+nxwg*(fineLocInCoarse[1].first+ghostSize)),fact1(facts[1]),fact0(facts[0]);
471 inPtr+=(dims[0]*fact0+2*ghostSize)*ghostSize*nbCompo;
472 for(int j=0;j<dims[1];j++)
474 for(mcIdType jfact=0;jfact<fact1;jfact++)
476 inPtr+=ghostSize*nbCompo;
477 for(int i=0;i<dims[0];i++)
479 double *loc(outPtr+(kk+i)*nbCompo);
480 for(mcIdType ifact=0;ifact<fact0;ifact++,inPtr+=nbCompo)
482 if(jfact!=0 || ifact!=0)
483 std::transform(inPtr,inPtr+nbCompo,loc,loc,std::plus<double>());
485 std::copy(inPtr,inPtr+nbCompo,loc);
488 inPtr+=ghostSize*nbCompo;
496 mcIdType nxwg(coarseSt[0]+2*ghostSize),nxywg((coarseSt[0]+2*ghostSize)*(coarseSt[1]+2*ghostSize));
497 mcIdType kk(fineLocInCoarse[0].first+ghostSize+nxwg*(fineLocInCoarse[1].first+ghostSize)+nxywg*(fineLocInCoarse[2].first+ghostSize)),fact2(facts[2]),fact1(facts[1]),fact0(facts[0]);
498 inPtr+=(dims[0]*fact0+2*ghostSize)*(dims[1]*fact1+2*ghostSize)*ghostSize*nbCompo;
499 for(int k=0;k<dims[2];k++)
501 for(mcIdType kfact=0;kfact<fact2;kfact++)
503 inPtr+=ghostSize*(dims[0]*fact0+2*ghostSize)*nbCompo;
504 for(int j=0;j<dims[1];j++)
506 mcIdType kky(j*nxwg);
507 for(mcIdType jfact=0;jfact<fact1;jfact++)
509 inPtr+=ghostSize*nbCompo;
510 for(int i=0;i<dims[0];i++)
512 double *loc(outPtr+(kky+kk+i)*nbCompo);
513 for(mcIdType ifact=0;ifact<fact0;ifact++,inPtr+=nbCompo)
515 if(kfact!=0 || jfact!=0 || ifact!=0)
516 std::transform(inPtr,inPtr+nbCompo,loc,loc,std::plus<double>());
518 std::copy(inPtr,inPtr+nbCompo,loc);
521 inPtr+=ghostSize*nbCompo;
524 inPtr+=ghostSize*(dims[0]*fact0+2*ghostSize)*nbCompo;
531 throw INTERP_KERNEL::Exception("MEDCouplingIMesh::CondenseFineToCoarseGhost : only dimensions 1, 2, 3 supported !");
536 * This method spreads the values of coarse data \a coarseDA into \a fineDA.
538 * \param [in] coarseDA The DataArrayDouble corresponding to the a cell field of a coarse mesh whose cell structure is defined by \a coarseSt.
539 * \param [in] coarseSt The cell structure of coarse mesh.
540 * \param [in,out] fineDA The DataArray containing the cell field on uniformly refined mesh
541 * \param [in] fineLocInCoarse The cell localization of refined mesh into the coarse one.
542 * \param [in] facts The refinement coefficient per axis.
543 * \sa SpreadCoarseToFineGhost, CondenseFineToCoarse
545 void MEDCouplingIMesh::SpreadCoarseToFine(const DataArrayDouble *coarseDA, const std::vector<mcIdType>& coarseSt, DataArrayDouble *fineDA, const std::vector< std::pair<mcIdType,mcIdType> >& fineLocInCoarse, const std::vector<mcIdType>& facts)
547 if(coarseSt.size()!=fineLocInCoarse.size() || coarseSt.size()!=facts.size())
548 throw INTERP_KERNEL::Exception("MEDCouplingIMesh::SpreadCoarseToFine : All input vectors (dimension) must have the same size !");
549 if(!coarseDA || !coarseDA->isAllocated() || !fineDA || !fineDA->isAllocated())
550 throw INTERP_KERNEL::Exception("MEDCouplingIMesh::SpreadCoarseToFine : the parameters 1 or 3 are NULL or not allocated !");
551 std::size_t meshDim(coarseSt.size());
552 mcIdType nbOfTuplesInCoarseExp(MEDCouplingStructuredMesh::DeduceNumberOfGivenStructure(coarseSt)),nbOfTuplesInFineExp(MEDCouplingStructuredMesh::DeduceNumberOfGivenRangeInCompactFrmt(fineLocInCoarse));
553 std::size_t nbCompo=fineDA->getNumberOfComponents();
554 if(coarseDA->getNumberOfComponents()!=nbCompo)
555 throw INTERP_KERNEL::Exception("MEDCouplingIMesh::SpreadCoarseToFine : the number of components of fine DA and coarse one mismatches !");
556 if(meshDim!=fineLocInCoarse.size() || meshDim!=facts.size())
557 throw INTERP_KERNEL::Exception("MEDCouplingIMesh::SpreadCoarseToFine : the size of fineLocInCoarse (4th param) and facts (5th param) must be equal to the sier of coarseSt (2nd param) !");
558 if(coarseDA->getNumberOfTuples()!=nbOfTuplesInCoarseExp)
560 std::ostringstream oss; oss << "MEDCouplingIMesh::SpreadCoarseToFine : Expecting " << nbOfTuplesInCoarseExp << " tuples having " << coarseDA->getNumberOfTuples() << " !";
561 throw INTERP_KERNEL::Exception(oss.str().c_str());
563 mcIdType nbTuplesFine(fineDA->getNumberOfTuples());
564 if(nbTuplesFine%nbOfTuplesInFineExp!=0)
565 throw INTERP_KERNEL::Exception("MEDCouplingIMesh::SpreadCoarseToFine : Invalid nb of tuples in fine DataArray regarding its structure !");
566 mcIdType fact(std::accumulate(facts.begin(),facts.end(),1,std::multiplies<mcIdType>()));
567 if(nbTuplesFine!=fact*nbOfTuplesInFineExp)
569 std::ostringstream oss; oss << "MEDCouplingIMesh::SpreadCoarseToFine : Invalid number of tuples (" << nbTuplesFine << ") of fine dataarray is invalid ! Must be " << fact*nbOfTuplesInFineExp << "!";
570 throw INTERP_KERNEL::Exception(oss.str().c_str());
572 // to improve use jump-iterator. Factorizes with SwitchOnIdsFrom BuildExplicitIdsFrom
573 double *outPtr(fineDA->getPointer());
574 const double *inPtr(coarseDA->begin());
576 std::vector<mcIdType> dims(MEDCouplingStructuredMesh::GetDimensionsFromCompactFrmt(fineLocInCoarse));
581 mcIdType offset(fineLocInCoarse[0].first),fact0(facts[0]);
582 for(int i=0;i<dims[0];i++)
584 const double *loc(inPtr+(offset+i)*nbCompo);
585 for(mcIdType ifact=0;ifact<fact0;ifact++)
586 outPtr=std::copy(loc,loc+nbCompo,outPtr);
592 mcIdType kk(fineLocInCoarse[0].first+coarseSt[0]*fineLocInCoarse[1].first),fact0(facts[0]),fact1(facts[1]);
593 for(int j=0;j<dims[1];j++)
595 for(mcIdType jfact=0;jfact<fact1;jfact++)
597 for(int i=0;i<dims[0];i++)
599 const double *loc(inPtr+(kk+i)*nbCompo);
600 for(mcIdType ifact=0;ifact<fact0;ifact++)
601 outPtr=std::copy(loc,loc+nbCompo,outPtr);
610 mcIdType kk(fineLocInCoarse[0].first+coarseSt[0]*fineLocInCoarse[1].first+coarseSt[0]*coarseSt[1]*fineLocInCoarse[2].first),fact0(facts[0]),fact1(facts[2]),fact2(facts[2]);
611 for(int k=0;k<dims[2];k++)
613 for(mcIdType kfact=0;kfact<fact2;kfact++)
615 for(int j=0;j<dims[1];j++)
617 for(mcIdType jfact=0;jfact<fact1;jfact++)
619 for(int i=0;i<dims[0];i++)
621 const double *loc(inPtr+(kk+i+j*coarseSt[0])*nbCompo);
622 for(mcIdType ifact=0;ifact<fact0;ifact++)
623 outPtr=std::copy(loc,loc+nbCompo,outPtr);
628 kk+=coarseSt[0]*coarseSt[1];
633 throw INTERP_KERNEL::Exception("MEDCouplingIMesh::SpreadCoarseToFine : only dimensions 1, 2 and 3 supported !");
638 * This method spreads the values of coarse data \a coarseDA into \a fineDA.
640 * \param [in] coarseDA The DataArrayDouble corresponding to the a cell field of a coarse mesh whose cell structure is defined by \a coarseSt.
641 * \param [in] coarseSt The cell structure of coarse mesh.
642 * \param [in,out] fineDA The DataArray containing the cell field on uniformly refined mesh
643 * \param [in] fineLocInCoarse The cell localization of refined mesh into the coarse one.
644 * \param [in] facts The refinement coefficient per axis.
645 * \param [in] ghostSize - The size of the ghost zone. The ghost zone is expected to be the same for all axis and both for coarse and fine meshes.
647 * \sa CondenseFineToCoarse, SpreadCoarseToFineGhostZone
649 void MEDCouplingIMesh::SpreadCoarseToFineGhost(const DataArrayDouble *coarseDA, const std::vector<mcIdType>& coarseSt, DataArrayDouble *fineDA, const std::vector< std::pair<mcIdType,mcIdType> >& fineLocInCoarse, const std::vector<mcIdType>& facts, mcIdType ghostSize)
652 throw INTERP_KERNEL::Exception("MEDCouplingIMesh::SpreadCoarseToFineGhost : ghost level has to be >= 0 !");
653 if(coarseSt.size()!=fineLocInCoarse.size() || coarseSt.size()!=facts.size())
654 throw INTERP_KERNEL::Exception("MEDCouplingIMesh::SpreadCoarseToFineGhost : All input vectors (dimension) must have the same size !");
655 if(!coarseDA || !coarseDA->isAllocated() || !fineDA || !fineDA->isAllocated())
656 throw INTERP_KERNEL::Exception("MEDCouplingIMesh::SpreadCoarseToFineGhost : the parameters 1 or 3 are NULL or not allocated !");
657 std::vector<mcIdType> coarseStG(coarseSt.size()); std::transform(coarseSt.begin(),coarseSt.end(),coarseStG.begin(),std::bind(std::plus<mcIdType>(),std::placeholders::_1,2*ghostSize));
658 std::size_t meshDim(coarseSt.size());
659 mcIdType nbOfTuplesInCoarseExp(MEDCouplingStructuredMesh::DeduceNumberOfGivenStructure(coarseStG));
660 std::size_t nbCompo=fineDA->getNumberOfComponents();
661 if(coarseDA->getNumberOfComponents()!=nbCompo)
662 throw INTERP_KERNEL::Exception("MEDCouplingIMesh::SpreadCoarseToFineGhost : the number of components of fine DA and coarse one mismatches !");
663 if(meshDim!=fineLocInCoarse.size() || meshDim!=facts.size())
664 throw INTERP_KERNEL::Exception("MEDCouplingIMesh::SpreadCoarseToFineGhost : the size of fineLocInCoarse (4th param) and facts (5th param) must be equal to the sier of coarseSt (2nd param) !");
665 if(coarseDA->getNumberOfTuples()!=nbOfTuplesInCoarseExp)
667 std::ostringstream oss; oss << "MEDCouplingIMesh::SpreadCoarseToFineGhost : Expecting " << nbOfTuplesInCoarseExp << " tuples having " << coarseDA->getNumberOfTuples() << " !";
668 throw INTERP_KERNEL::Exception(oss.str().c_str());
671 std::vector<mcIdType> fineStG(MEDCouplingStructuredMesh::GetDimensionsFromCompactFrmt(fineLocInCoarse));
672 std::transform(fineStG.begin(),fineStG.end(),facts.begin(),fineStG.begin(),std::multiplies<mcIdType>());
673 std::transform(fineStG.begin(),fineStG.end(),fineStG.begin(),std::bind(std::plus<mcIdType>(),std::placeholders::_1,2*ghostSize));
674 mcIdType nbTuplesFine(fineDA->getNumberOfTuples()),nbTuplesFineExp(MEDCouplingStructuredMesh::DeduceNumberOfGivenStructure(fineStG));
675 if(fineDA->getNumberOfTuples()!=nbTuplesFineExp)
677 std::ostringstream oss; oss << "MEDCouplingIMesh::SpreadCoarseToFineGhost : Expecting " << nbTuplesFineExp << " tuples in fine DataArray having " << nbTuplesFine << " !";
678 throw INTERP_KERNEL::Exception(oss.str().c_str());
681 double *outPtr(fineDA->getPointer());
682 const double *inPtr(coarseDA->begin());
688 std::vector<mcIdType> dims(MEDCouplingStructuredMesh::GetDimensionsFromCompactFrmt(fineLocInCoarse));
689 mcIdType offset(fineLocInCoarse[0].first+ghostSize-1),fact0(facts[0]);//offset is always >=0 thanks to the fact that ghostSize>=1 !
690 for(mcIdType i=0;i<ghostSize;i++)
691 outPtr=std::copy(inPtr+offset*nbCompo,inPtr+(offset+1)*nbCompo,outPtr);
692 offset=fineLocInCoarse[0].first+ghostSize;
693 for(int i=0;i<dims[0];i++)
695 const double *loc(inPtr+(offset+i)*nbCompo);
696 for(mcIdType ifact=0;ifact<fact0;ifact++)
697 outPtr=std::copy(loc,loc+nbCompo,outPtr);
699 offset=fineLocInCoarse[0].second+ghostSize;
700 for(mcIdType i=0;i<ghostSize;i++)
701 outPtr=std::copy(inPtr+offset*nbCompo,inPtr+(offset+1)*nbCompo,outPtr);
706 SpreadCoarseToFineGhost2D(inPtr,outPtr,nbCompo,coarseSt,fineLocInCoarse,facts,ghostSize);
711 std::vector<mcIdType> dims(MEDCouplingStructuredMesh::GetDimensionsFromCompactFrmt(fineLocInCoarse));
712 mcIdType fact0(facts[0]),fact1(facts[1]),fact2(facts[2]);
713 mcIdType nxyWgCoarse((coarseSt[0]+2*ghostSize)*(coarseSt[1]+2*ghostSize)),nxyWgFine((dims[0]*fact0+2*ghostSize)*(dims[1]*fact1+2*ghostSize));
714 mcIdType offset((fineLocInCoarse[2].first+ghostSize-1)*nxyWgCoarse);//offset is always >=0 thanks to the fact that ghostSize>=1 !
715 for(mcIdType i=0;i<ghostSize;i++,outPtr+=nxyWgFine*nbCompo)
716 SpreadCoarseToFineGhost2D(inPtr+offset*nbCompo,outPtr,nbCompo,coarseSt,fineLocInCoarse,facts,ghostSize);
718 for(int i=0;i<dims[2];i++,offset+=nxyWgCoarse)
719 for(mcIdType j=0;j<fact2;j++,outPtr+=nxyWgFine*nbCompo)
720 SpreadCoarseToFineGhost2D(inPtr+offset*nbCompo,outPtr,nbCompo,coarseSt,fineLocInCoarse,facts,ghostSize);
721 for(mcIdType i=0;i<ghostSize;i++,outPtr+=nxyWgFine*nbCompo)
722 SpreadCoarseToFineGhost2D(inPtr+offset*nbCompo,outPtr,nbCompo,coarseSt,fineLocInCoarse,facts,ghostSize);
726 throw INTERP_KERNEL::Exception("MEDCouplingIMesh::SpreadCoarseToFineGhost : only dimensions 1, 2, 3 supported !");
731 * This method spreads the values of coarse data \a coarseDA into \a fineDA \b ONLY \b in \b the \b ghost \b zone (contrary to SpreadCoarseToFineGhost that spread the values everywhere).
733 * \param [in] coarseDA The DataArrayDouble corresponding to the a cell field of a coarse mesh whose cell structure is defined by \a coarseSt.
734 * \param [in] coarseSt The cell structure of coarse mesh.
735 * \param [in,out] fineDA The DataArray containing the cell field on uniformly refined mesh
736 * \param [in] fineLocInCoarse The cell localization of refined mesh into the coarse one.
737 * \param [in] facts The refinement coefficient per axis.
738 * \param [in] ghostSize - The size of the ghost zone. The ghost zone is expected to be the same for all axis and both for coarse and fine meshes.
740 * \sa SpreadCoarseToFineGhost
742 void MEDCouplingIMesh::SpreadCoarseToFineGhostZone(const DataArrayDouble *coarseDA, const std::vector<mcIdType>& coarseSt, DataArrayDouble *fineDA, const std::vector< std::pair<mcIdType,mcIdType> >& fineLocInCoarse, const std::vector<mcIdType>& facts, mcIdType ghostSize)
745 throw INTERP_KERNEL::Exception("MEDCouplingIMesh::SpreadCoarseToFineGhostZone : ghost level has to be >= 0 !");
746 if(coarseSt.size()!=fineLocInCoarse.size() || coarseSt.size()!=facts.size())
747 throw INTERP_KERNEL::Exception("MEDCouplingIMesh::SpreadCoarseToFineGhostZone : All input vectors (dimension) must have the same size !");
748 if(!coarseDA || !coarseDA->isAllocated() || !fineDA || !fineDA->isAllocated())
749 throw INTERP_KERNEL::Exception("MEDCouplingIMesh::SpreadCoarseToFineGhostZone : the parameters 1 or 3 are NULL or not allocated !");
750 std::vector<mcIdType> coarseStG(coarseSt.size()); std::transform(coarseSt.begin(),coarseSt.end(),coarseStG.begin(),std::bind(std::plus<mcIdType>(),std::placeholders::_1,2*ghostSize));
751 std::size_t meshDim(coarseSt.size());
752 mcIdType nbOfTuplesInCoarseExp(MEDCouplingStructuredMesh::DeduceNumberOfGivenStructure(coarseStG));
753 std::size_t nbCompo=fineDA->getNumberOfComponents();
754 if(coarseDA->getNumberOfComponents()!=nbCompo)
755 throw INTERP_KERNEL::Exception("MEDCouplingIMesh::SpreadCoarseToFineGhostZone : the number of components of fine DA and coarse one mismatches !");
756 if(meshDim!=fineLocInCoarse.size() || meshDim!=facts.size())
757 throw INTERP_KERNEL::Exception("MEDCouplingIMesh::SpreadCoarseToFineGhostZone : the size of fineLocInCoarse (4th param) and facts (5th param) must be equal to the sier of coarseSt (2nd param) !");
758 if(coarseDA->getNumberOfTuples()!=nbOfTuplesInCoarseExp)
760 std::ostringstream oss; oss << "MEDCouplingIMesh::SpreadCoarseToFineGhostZone : Expecting " << nbOfTuplesInCoarseExp << " tuples having " << coarseDA->getNumberOfTuples() << " !";
761 throw INTERP_KERNEL::Exception(oss.str().c_str());
764 std::vector<mcIdType> fineStG(MEDCouplingStructuredMesh::GetDimensionsFromCompactFrmt(fineLocInCoarse));
765 std::transform(fineStG.begin(),fineStG.end(),facts.begin(),fineStG.begin(),std::multiplies<mcIdType>());
766 std::transform(fineStG.begin(),fineStG.end(),fineStG.begin(),std::bind(std::plus<mcIdType>(),std::placeholders::_1,2*ghostSize));
767 mcIdType nbTuplesFine(fineDA->getNumberOfTuples()),nbTuplesFineExp(MEDCouplingStructuredMesh::DeduceNumberOfGivenStructure(fineStG));
768 if(fineDA->getNumberOfTuples()!=nbTuplesFineExp)
770 std::ostringstream oss; oss << "MEDCouplingIMesh::SpreadCoarseToFineGhostZone : Expecting " << nbTuplesFineExp << " tuples in fine DataArray having " << nbTuplesFine << " !";
771 throw INTERP_KERNEL::Exception(oss.str().c_str());
774 double *outPtr(fineDA->getPointer());
775 const double *inPtr(coarseDA->begin());
777 std::vector<mcIdType> dims(MEDCouplingStructuredMesh::GetDimensionsFromCompactFrmt(fineLocInCoarse));
782 mcIdType offset(fineLocInCoarse[0].first+ghostSize-1),fact0(facts[0]);//offset is always >=0 thanks to the fact that ghostSize>=1 !
783 for(mcIdType i=0;i<ghostSize;i++)
784 outPtr=std::copy(inPtr+offset*nbCompo,inPtr+(offset+1)*nbCompo,outPtr);
785 outPtr+=nbCompo*fact0*dims[0];
786 offset=fineLocInCoarse[0].second+ghostSize;
787 for(mcIdType i=0;i<ghostSize;i++)
788 outPtr=std::copy(inPtr+offset*nbCompo,inPtr+(offset+1)*nbCompo,outPtr);
793 SpreadCoarseToFineGhostZone2D(inPtr,outPtr,ToIdType(nbCompo),coarseSt,fineLocInCoarse,facts,ghostSize);
798 mcIdType fact0(facts[0]),fact1(facts[1]),fact2(facts[2]);
799 mcIdType nxyWgCoarse((coarseSt[0]+2*ghostSize)*(coarseSt[1]+2*ghostSize)),nxyWgFine((dims[0]*fact0+2*ghostSize)*(dims[1]*fact1+2*ghostSize));
800 mcIdType offset((fineLocInCoarse[2].first+ghostSize-1)*nxyWgCoarse);//offset is always >=0 thanks to the fact that ghostSize>=1 !
801 for(mcIdType i=0;i<ghostSize;i++,outPtr+=nxyWgFine*nbCompo)
802 SpreadCoarseToFineGhost2D(inPtr+offset*nbCompo,outPtr,ToIdType(nbCompo),coarseSt,fineLocInCoarse,facts,ghostSize);
804 for(int i=0;i<dims[2];i++,offset+=nxyWgCoarse)
805 for(mcIdType j=0;j<fact2;j++,outPtr+=nxyWgFine*nbCompo)
806 SpreadCoarseToFineGhostZone2D(inPtr+offset*nbCompo,outPtr,ToIdType(nbCompo),coarseSt,fineLocInCoarse,facts,ghostSize);
807 for(mcIdType i=0;i<ghostSize;i++,outPtr+=nxyWgFine*nbCompo)
808 SpreadCoarseToFineGhost2D(inPtr+offset*nbCompo,outPtr,ToIdType(nbCompo),coarseSt,fineLocInCoarse,facts,ghostSize);
812 throw INTERP_KERNEL::Exception("MEDCouplingIMesh::SpreadCoarseToFineGhostZone : only dimensions 1, 2, 3 supported !");
816 void MEDCouplingIMesh::setSpaceDimension(int spaceDim)
818 if(spaceDim==_space_dim)
820 CheckSpaceDimension(spaceDim);
825 void MEDCouplingIMesh::updateTime() const
829 std::size_t MEDCouplingIMesh::getHeapMemorySizeWithoutChildren() const
831 return MEDCouplingStructuredMesh::getHeapMemorySizeWithoutChildren();
834 std::vector<const BigMemoryObject *> MEDCouplingIMesh::getDirectChildrenWithNull() const
836 return std::vector<const BigMemoryObject *>();
840 * This method copyies all tiny strings from other (name and components name).
841 * @throw if other and this have not same mesh type.
843 void MEDCouplingIMesh::copyTinyStringsFrom(const MEDCouplingMesh *other)
845 const MEDCouplingIMesh *otherC=dynamic_cast<const MEDCouplingIMesh *>(other);
847 throw INTERP_KERNEL::Exception("MEDCouplingIMesh::copyTinyStringsFrom : meshes have not same type !");
848 MEDCouplingStructuredMesh::copyTinyStringsFrom(other);
852 bool MEDCouplingIMesh::isEqualIfNotWhy(const MEDCouplingMesh *other, double prec, std::string& reason) const
855 throw INTERP_KERNEL::Exception("MEDCouplingIMesh::isEqualIfNotWhy : input other pointer is null !");
856 const MEDCouplingIMesh *otherC(dynamic_cast<const MEDCouplingIMesh *>(other));
859 reason="mesh given in input is not castable in MEDCouplingIMesh !";
862 if(!MEDCouplingStructuredMesh::isEqualIfNotWhy(other,prec,reason))
864 if(!isEqualWithoutConsideringStrInternal(otherC,prec,reason))
866 if(_axis_unit!=otherC->_axis_unit)
868 reason="The units of axis are not the same !";
874 bool MEDCouplingIMesh::isEqualWithoutConsideringStr(const MEDCouplingMesh *other, double prec) const
876 const MEDCouplingIMesh *otherC=dynamic_cast<const MEDCouplingIMesh *>(other);
880 return isEqualWithoutConsideringStrInternal(other,prec,tmp);
883 bool MEDCouplingIMesh::isEqualWithoutConsideringStrInternal(const MEDCouplingMesh *other, double prec, std::string& reason) const
885 const MEDCouplingIMesh *otherC=dynamic_cast<const MEDCouplingIMesh *>(other);
888 if(_space_dim!=otherC->_space_dim)
890 std::ostringstream oss;
891 oss << "The spaceDimension of this (" << _space_dim << ") is not equal to those of other (" << otherC->_space_dim << ") !";
894 checkSpaceDimension();
895 for(int i=0;i<_space_dim;i++)
897 if(fabs(_origin[i]-otherC->_origin[i])>prec)
899 std::ostringstream oss;
900 oss << "The origin of this and other differs at " << i << " !";
905 for(int i=0;i<_space_dim;i++)
907 if(fabs(_dxyz[i]-otherC->_dxyz[i])>prec)
909 std::ostringstream oss;
910 oss << "The delta of this and other differs at " << i << " !";
915 for(int i=0;i<_space_dim;i++)
917 if(_structure[i]!=otherC->_structure[i])
919 std::ostringstream oss;
920 oss << "The structure of this and other differs at " << i << " !";
928 void MEDCouplingIMesh::checkDeepEquivalWith(const MEDCouplingMesh *other, int cellCompPol, double prec,
929 DataArrayIdType *&cellCor, DataArrayIdType *&nodeCor) const
931 if(!isEqualWithoutConsideringStr(other,prec))
932 throw INTERP_KERNEL::Exception("MEDCouplingIMesh::checkDeepEquivalWith : Meshes are not the same !");
936 * Nothing is done here (except to check that the other is a MEDCoupling::MEDCouplingIMesh instance too).
937 * The user intend that the nodes are the same, so by construction of MEDCoupling::MEDCouplingIMesh, \a this and \a other are the same !
939 void MEDCouplingIMesh::checkDeepEquivalOnSameNodesWith(const MEDCouplingMesh *other, int cellCompPol, double prec,
940 DataArrayIdType *&cellCor) const
942 if(!isEqualWithoutConsideringStr(other,prec))
943 throw INTERP_KERNEL::Exception("MEDCouplingIMesh::checkDeepEquivalOnSameNodesWith : Meshes are not the same !");
946 void MEDCouplingIMesh::checkConsistencyLight() const
948 checkSpaceDimension();
949 for(int i=0;i<_space_dim;i++)
952 std::ostringstream oss; oss << "MEDCouplingIMesh::checkConsistencyLight : On axis " << i << "/" << _space_dim << ", number of nodes is equal to " << _structure[i] << " ! must be >=1 !";
953 throw INTERP_KERNEL::Exception(oss.str().c_str());
957 void MEDCouplingIMesh::checkConsistency(double eps) const
959 checkConsistencyLight();
962 void MEDCouplingIMesh::getNodeGridStructure(mcIdType *res) const
964 checkSpaceDimension();
965 std::copy(_structure,_structure+_space_dim,res);
968 std::vector<mcIdType> MEDCouplingIMesh::getNodeGridStructure() const
970 checkSpaceDimension();
971 std::vector<mcIdType> ret(_structure,_structure+_space_dim);
975 MEDCouplingStructuredMesh *MEDCouplingIMesh::buildStructuredSubPart(const std::vector< std::pair<mcIdType,mcIdType> >& cellPart) const
977 checkConsistencyLight();
978 int dim(getSpaceDimension());
979 if(dim!=ToIdType(cellPart.size()))
981 std::ostringstream oss; oss << "MEDCouplingIMesh::buildStructuredSubPart : the space dimension is " << dim << " and cell part size is " << cellPart.size() << " !";
982 throw INTERP_KERNEL::Exception(oss.str().c_str());
984 double retOrigin[3]={0.,0.,0.};
985 mcIdType retStruct[3]={0,0,0};
986 MCAuto<MEDCouplingIMesh> ret(dynamic_cast<MEDCouplingIMesh *>(deepCopy()));
987 for(int i=0;i<dim;i++)
989 mcIdType startNode(cellPart[i].first),endNode(cellPart[i].second+1);
990 mcIdType myDelta(endNode-startNode);
991 if(startNode<0 || startNode>=_structure[i])
993 std::ostringstream oss; oss << "MEDCouplingIMesh::buildStructuredSubPart : At dimension #" << i << " the start node id is " << startNode << " it should be in [0," << _structure[i] << ") !";
994 throw INTERP_KERNEL::Exception(oss.str().c_str());
996 if(myDelta<0 || myDelta>_structure[i])
998 std::ostringstream oss; oss << "MEDCouplingIMesh::buildStructuredSubPart : Along dimension #" << i << " the number of nodes is " << _structure[i] << ", and you are requesting for " << myDelta << " nodes wide range !" << std::endl;
999 throw INTERP_KERNEL::Exception(oss.str().c_str());
1001 retOrigin[i]=_origin[i]+FromIdType<double>(startNode)*_dxyz[i];
1002 retStruct[i]=myDelta;
1004 ret->setNodeStruct(retStruct,retStruct+dim);
1005 ret->setOrigin(retOrigin,retOrigin+dim);
1006 ret->checkConsistencyLight();
1011 * Return the space dimension of \a this.
1013 int MEDCouplingIMesh::getSpaceDimension() const
1018 void MEDCouplingIMesh::getCoordinatesOfNode(mcIdType nodeId, std::vector<double>& coo) const
1021 int spaceDim(getSpaceDimension());
1022 getSplitNodeValues(tmp);
1024 GetPosFromId(nodeId,spaceDim,tmp,tmp2);
1025 for(int j=0;j<spaceDim;j++)
1026 coo.push_back(_origin[j]+_dxyz[j]*FromIdType<double>(tmp2[j]));
1029 std::string MEDCouplingIMesh::simpleRepr() const
1031 std::ostringstream ret;
1032 ret << "Image grid with name : \"" << getName() << "\"\n";
1033 ret << "Description of mesh : \"" << getDescription() << "\"\n";
1035 double tt(getTime(tmpp1,tmpp2));
1036 int spaceDim(_space_dim);
1037 ret << "Time attached to the mesh [unit] : " << tt << " [" << getTimeUnit() << "]\n";
1038 ret << "Iteration : " << tmpp1 << " Order : " << tmpp2 << "\n";
1039 ret << "Space dimension : " << spaceDim << "\n";
1040 if(spaceDim<0 || spaceDim>3)
1042 ret << "The nodal structure is : "; std::copy(_structure,_structure+spaceDim,std::ostream_iterator<int>(ret," ")); ret << "\n";
1043 ret << "The origin position is [" << _axis_unit << "]: ";
1044 std::copy(_origin,_origin+spaceDim,std::ostream_iterator<double>(ret," ")); ret << "\n";
1045 ret << "The intervals along axis are : ";
1046 std::copy(_dxyz,_dxyz+spaceDim,std::ostream_iterator<double>(ret," ")); ret << "\n";
1050 std::string MEDCouplingIMesh::advancedRepr() const
1052 return simpleRepr();
1055 void MEDCouplingIMesh::getBoundingBox(double *bbox) const
1057 checkConsistencyLight();
1058 int dim(getSpaceDimension());
1059 for(int idim=0; idim<dim; idim++)
1061 bbox[2*idim]=_origin[idim];
1062 mcIdType coeff(_structure[idim]);
1063 if(_structure[idim]<0)
1065 std::ostringstream oss; oss << "MEDCouplingIMesh::getBoundingBox : on axis #" << idim << " number of nodes in structure is < 0 !";
1066 throw INTERP_KERNEL::Exception(oss.str().c_str());
1068 if(_structure[idim]>1)
1069 coeff=_structure[idim]-1;
1070 bbox[2*idim+1]=_origin[idim]+_dxyz[idim]*FromIdType<double>(coeff);
1075 * Returns a new MEDCouplingFieldDouble containing volumes of cells constituting \a this
1077 * For 1D cells, the returned field contains lengths.<br>
1078 * For 2D cells, the returned field contains areas.<br>
1079 * For 3D cells, the returned field contains volumes.
1080 * \param [in] isAbs - a not used parameter.
1081 * \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble on cells
1082 * and one time . The caller is to delete this field using decrRef() as it is no
1085 MEDCouplingFieldDouble *MEDCouplingIMesh::getMeasureField(bool isAbs) const
1087 checkConsistencyLight();
1088 std::string name="MeasureOfMesh_";
1090 std::size_t nbelem=getNumberOfCells();
1091 MEDCouplingFieldDouble *field(MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME));
1092 field->setName(name);
1093 DataArrayDouble* array(DataArrayDouble::New());
1094 array->alloc(nbelem,1);
1095 array->fillWithValue(getMeasureOfAnyCell());
1096 field->setArray(array) ;
1098 field->setMesh(const_cast<MEDCouplingIMesh *>(this));
1099 field->synchronizeTimeWithMesh();
1104 * not implemented yet !
1106 MEDCouplingFieldDouble *MEDCouplingIMesh::getMeasureFieldOnNode(bool isAbs) const
1108 throw INTERP_KERNEL::Exception("MEDCouplingIMesh::getMeasureFieldOnNode : not implemented yet !");
1112 mcIdType MEDCouplingIMesh::getCellContainingPoint(const double *pos, double eps) const
1114 mcIdType dim(getSpaceDimension()),ret(0),coeff(1);
1115 for(mcIdType i=0;i<dim;i++)
1117 mcIdType nbOfCells(_structure[i]-1);
1119 mcIdType tmp(ToIdType((ref-_origin[i])/_dxyz[i]));
1120 if(tmp>=0 && tmp<nbOfCells)
1131 void MEDCouplingIMesh::getCellsContainingPoint(const double *pos, double eps, std::vector<mcIdType>& elts) const
1133 mcIdType ret(getCellContainingPoint(pos,eps));
1134 elts.push_back(ret);
1137 void MEDCouplingIMesh::rotate(const double *center, const double *vector, double angle)
1139 throw INTERP_KERNEL::Exception("No rotation available on IMesh : Traduce it to unstructured mesh to apply it !");
1143 * Translates all nodes of \a this mesh by a given vector. Actually, it adds each
1144 * component of the \a vector to all node coordinates of a corresponding axis.
1145 * \param [in] vector - the translation vector whose size must be not less than \a
1146 * this->getSpaceDimension().
1148 void MEDCouplingIMesh::translate(const double *vector)
1150 checkSpaceDimension();
1151 int dim(getSpaceDimension());
1152 std::transform(_origin,_origin+dim,vector,_origin,std::plus<double>());
1157 * Applies scaling transformation to all nodes of \a this mesh.
1158 * \param [in] point - coordinates of a scaling center. This array is to be of
1159 * size \a this->getSpaceDimension() at least.
1160 * \param [in] factor - a scale factor.
1162 void MEDCouplingIMesh::scale(const double *point, double factor)
1164 checkSpaceDimension();
1165 int dim(getSpaceDimension());
1166 std::transform(_origin,_origin+dim,point,_origin,std::minus<double>());
1167 std::transform(_origin,_origin+dim,_origin,std::bind(std::multiplies<double>(),std::placeholders::_1,factor));
1168 std::transform(_dxyz,_dxyz+dim,_dxyz,std::bind(std::multiplies<double>(),std::placeholders::_1,factor));
1169 std::transform(_origin,_origin+dim,point,_origin,std::plus<double>());
1173 MEDCouplingMesh *MEDCouplingIMesh::mergeMyselfWith(const MEDCouplingMesh *other) const
1175 //not implemented yet !
1180 * Returns a new DataArrayDouble holding coordinates of all nodes of \a this mesh.
1181 * \return DataArrayDouble * - a new instance of DataArrayDouble, of size \a
1182 * this->getNumberOfNodes() tuples per \a this->getSpaceDimension()
1183 * components. The caller is to delete this array using decrRef() as it is
1186 DataArrayDouble *MEDCouplingIMesh::getCoordinatesAndOwner() const
1188 checkConsistencyLight();
1189 MCAuto<DataArrayDouble> ret(DataArrayDouble::New());
1190 int spaceDim(getSpaceDimension());
1191 mcIdType nbNodes(getNumberOfNodes());
1192 ret->alloc(nbNodes,spaceDim);
1193 double *pt(ret->getPointer());
1194 ret->setInfoOnComponents(buildInfoOnComponents());
1195 mcIdType tmp2[3],tmp[3];
1196 getSplitNodeValues(tmp);
1197 for(mcIdType i=0;i<nbNodes;i++)
1199 GetPosFromId(i,spaceDim,tmp,tmp2);
1200 for(int j=0;j<spaceDim;j++)
1201 pt[i*spaceDim+j]=_dxyz[j]*FromIdType<double>(tmp2[j])+_origin[j];
1207 * Returns a new DataArrayDouble holding barycenters of all cells. The barycenter is
1208 * computed by averaging coordinates of cell nodes.
1209 * \return DataArrayDouble * - a new instance of DataArrayDouble, of size \a
1210 * this->getNumberOfCells() tuples per \a this->getSpaceDimension()
1211 * components. The caller is to delete this array using decrRef() as it is
1214 DataArrayDouble *MEDCouplingIMesh::computeCellCenterOfMass() const
1216 checkConsistencyLight();
1217 MCAuto<DataArrayDouble> ret(DataArrayDouble::New());
1218 int spaceDim(getSpaceDimension());
1219 mcIdType nbCells(ToIdType(getNumberOfCells())),tmp[3],tmp2[3];
1220 ret->alloc(nbCells,spaceDim);
1221 double *pt(ret->getPointer()),shiftOrigin[3];
1222 std::transform(_dxyz,_dxyz+spaceDim,shiftOrigin,std::bind(std::multiplies<double>(),std::placeholders::_1,0.5));
1223 std::transform(_origin,_origin+spaceDim,shiftOrigin,shiftOrigin,std::plus<double>());
1224 getSplitCellValues(tmp);
1225 ret->setInfoOnComponents(buildInfoOnComponents());
1226 for(mcIdType i=0;i<nbCells;i++)
1228 GetPosFromId(i,spaceDim,tmp,tmp2);
1229 for(int j=0;j<spaceDim;j++)
1230 pt[i*spaceDim+j]=_dxyz[j]*FromIdType<double>(tmp2[j])+shiftOrigin[j];
1235 DataArrayDouble *MEDCouplingIMesh::computeIsoBarycenterOfNodesPerCell() const
1237 return MEDCouplingIMesh::computeCellCenterOfMass();
1240 void MEDCouplingIMesh::renumberCells(const mcIdType *old2NewBg, bool check)
1242 throw INTERP_KERNEL::Exception("Functionality of renumbering cell not available for IMesh !");
1245 void MEDCouplingIMesh::getTinySerializationInformation(std::vector<double>& tinyInfoD, std::vector<mcIdType>& tinyInfo, std::vector<std::string>& littleStrings) const
1248 double time(getTime(it,order));
1251 littleStrings.clear();
1252 littleStrings.push_back(getName());
1253 littleStrings.push_back(getDescription());
1254 littleStrings.push_back(getTimeUnit());
1255 littleStrings.push_back(getAxisUnit());
1256 tinyInfo.push_back(it);
1257 tinyInfo.push_back(order);
1258 tinyInfo.push_back(_space_dim);
1259 tinyInfo.insert(tinyInfo.end(),_structure,_structure+3);
1260 tinyInfoD.push_back(time);
1261 tinyInfoD.insert(tinyInfoD.end(),_dxyz,_dxyz+3);
1262 tinyInfoD.insert(tinyInfoD.end(),_origin,_origin+3);
1265 void MEDCouplingIMesh::resizeForUnserialization(const std::vector<mcIdType>& tinyInfo, DataArrayIdType *a1, DataArrayDouble *a2, std::vector<std::string>& littleStrings) const
1271 void MEDCouplingIMesh::serialize(DataArrayIdType *&a1, DataArrayDouble *&a2) const
1273 a1=DataArrayIdType::New();
1275 a2=DataArrayDouble::New();
1279 void MEDCouplingIMesh::unserialization(const std::vector<double>& tinyInfoD, const std::vector<mcIdType>& tinyInfo, const DataArrayIdType *a1, DataArrayDouble *a2,
1280 const std::vector<std::string>& littleStrings)
1282 setName(littleStrings[0]);
1283 setDescription(littleStrings[1]);
1284 setTimeUnit(littleStrings[2]);
1285 setAxisUnit(littleStrings[3]);
1286 setTime(tinyInfoD[0],FromIdType<int>(tinyInfo[0]),FromIdType<int>(tinyInfo[1]));
1287 _space_dim=FromIdType<int>(tinyInfo[2]);
1288 _structure[0]=tinyInfo[3]; _structure[1]=tinyInfo[4]; _structure[2]=tinyInfo[5];
1289 _dxyz[0]=tinyInfoD[1]; _dxyz[1]=tinyInfoD[2]; _dxyz[2]=tinyInfoD[3];
1290 _origin[0]=tinyInfoD[4]; _origin[1]=tinyInfoD[5]; _origin[2]=tinyInfoD[6];
1294 void MEDCouplingIMesh::writeVTKLL(std::ostream& ofs, const std::string& cellData, const std::string& pointData, DataArrayByte *byteData) const
1296 checkConsistencyLight();
1297 std::ostringstream extent,origin,spacing;
1298 for(int i=0;i<3;i++)
1301 { extent << "0 " << _structure[i]-1 << " "; origin << _origin[i] << " "; spacing << _dxyz[i] << " "; }
1303 { extent << "0 0 "; origin << "0 "; spacing << "0 "; }
1305 ofs << " <" << getVTKDataSetType() << " WholeExtent=\"" << extent.str() << "\" Origin=\"" << origin.str() << "\" Spacing=\"" << spacing.str() << "\">\n";
1306 ofs << " <Piece Extent=\"" << extent.str() << "\">\n";
1307 ofs << " <PointData>\n" << pointData << std::endl;
1308 ofs << " </PointData>\n";
1309 ofs << " <CellData>\n" << cellData << std::endl;
1310 ofs << " </CellData>\n";
1311 ofs << " <Coordinates>\n";
1312 ofs << " </Coordinates>\n";
1313 ofs << " </Piece>\n";
1314 ofs << " </" << getVTKDataSetType() << ">\n";
1317 void MEDCouplingIMesh::reprQuickOverview(std::ostream& stream) const
1319 stream << "MEDCouplingIMesh C++ instance at " << this << ". Name : \"" << getName() << "\". Space dimension : " << _space_dim << ".";
1320 if(_space_dim<0 || _space_dim>3)
1323 std::ostringstream stream0,stream1;
1324 mcIdType nbNodes(1),nbCells(0);
1326 for(int i=0;i<_space_dim;i++)
1328 char tmp=(char)((int)('X')+i);
1329 mcIdType tmpNodes(_structure[i]);
1330 stream1 << "- Axis " << tmp << " : " << tmpNodes << " nodes (orig=" << _origin[i] << ", inter=" << _dxyz[i] << ").";
1332 stream1 << std::endl;
1338 nbCells=nbCells==0?tmpNodes-1:nbCells*(tmpNodes-1);
1342 stream0 << "Number of cells : " << nbCells << ", Number of nodes : " << nbNodes;
1343 stream << stream0.str();
1345 stream << std::endl;
1347 stream << stream1.str();
1350 std::string MEDCouplingIMesh::getVTKFileExtension() const
1352 return std::string("vti");
1355 std::string MEDCouplingIMesh::getVTKDataSetType() const
1357 return std::string("ImageData");
1360 std::vector<std::string> MEDCouplingIMesh::buildInfoOnComponents() const
1362 checkSpaceDimension();
1363 int dim(getSpaceDimension());
1364 std::vector<std::string> ret(dim);
1365 for(int i=0;i<dim;i++)
1367 std::ostringstream oss;
1368 char tmp=(char)((int)('X')+i); oss << tmp;
1369 ret[i]=DataArray::BuildInfoFromVarAndUnit(oss.str(),_axis_unit);
1374 void MEDCouplingIMesh::checkSpaceDimension() const
1376 CheckSpaceDimension(_space_dim);
1379 void MEDCouplingIMesh::CheckSpaceDimension(int spaceDim)
1381 if(spaceDim<0 || spaceDim>3)
1382 throw INTERP_KERNEL::Exception("MEDCouplingIMesh::CheckSpaceDimension : input spaceDim must be in [0,1,2,3] !");
1385 int MEDCouplingIMesh::FindIntRoot(int val, int order)
1390 throw INTERP_KERNEL::Exception("MEDCouplingIMesh::FindIntRoot : input val is < 0 ! Not possible to compute a root !");
1393 if(order!=2 && order!=3)
1394 throw INTERP_KERNEL::Exception("MEDCouplingIMesh::FindIntRoot : the order available are 0,1,2 or 3 !");
1395 double valf((double)val);
1398 double retf(sqrt(valf));
1401 throw INTERP_KERNEL::Exception("MEDCouplingIMesh::FindIntRoot : the input val is not a perfect square root !");
1406 double retf(std::pow(val,0.3333333333333333));
1407 int ret((int)retf),ret2(ret+1);
1408 if(ret*ret*ret!=val && ret2*ret2*ret2!=val)
1409 throw INTERP_KERNEL::Exception("MEDCouplingIMesh::FindIntRoot : the input val is not a perfect cublic root !");
1410 if(ret*ret*ret==val)
1417 void MEDCouplingIMesh::SpreadCoarseToFineGhost2D(const double *inPtr, double *outPtr, std::size_t nbCompo, const std::vector<mcIdType>& coarseSt, const std::vector< std::pair<mcIdType,mcIdType> >& fineLocInCoarse, const std::vector<mcIdType>& facts, mcIdType ghostSize)
1419 double *outPtrWork(outPtr);
1420 std::vector<mcIdType> dims(MEDCouplingStructuredMesh::GetDimensionsFromCompactFrmt(fineLocInCoarse));
1421 mcIdType nxwg(coarseSt[0]+2*ghostSize),fact0(facts[0]),fact1(facts[1]);
1422 mcIdType kk(fineLocInCoarse[0].first+ghostSize-1+nxwg*(fineLocInCoarse[1].first+ghostSize-1));//kk is always >=0 thanks to the fact that ghostSize>=1 !
1423 for(mcIdType jg=0;jg<ghostSize;jg++)
1425 for(mcIdType ig=0;ig<ghostSize;ig++)
1426 outPtrWork=std::copy(inPtr+kk*nbCompo,inPtr+(kk+1)*nbCompo,outPtrWork);
1428 for(mcIdType ig=0;ig<dims[0];ig++,kk0++)
1429 for(mcIdType ifact=0;ifact<fact0;ifact++)
1430 outPtrWork=std::copy(inPtr+(kk0)*nbCompo,inPtr+(kk0+1)*nbCompo,outPtrWork);
1431 for(mcIdType ik=0;ik<ghostSize;ik++)
1432 outPtrWork=std::copy(inPtr+kk0*nbCompo,inPtr+(kk0+1)*nbCompo,outPtrWork);
1434 for(mcIdType j=0;j<dims[1];j++)
1436 kk=fineLocInCoarse[0].first-1+ghostSize+nxwg*(fineLocInCoarse[1].first+ghostSize+j);
1437 for(mcIdType jfact=0;jfact<fact1;jfact++)
1439 for(mcIdType ig=0;ig<ghostSize;ig++)
1440 outPtrWork=std::copy(inPtr+kk*nbCompo,inPtr+(kk+1)*nbCompo,outPtrWork);
1441 mcIdType kk0(kk+1);//1 not ghost. We make the hypothesis that factors is >= ghostlev
1442 for(mcIdType i=0;i<dims[0];i++,kk0++)
1444 const double *loc(inPtr+kk0*nbCompo);
1445 for(mcIdType ifact=0;ifact<fact0;ifact++)
1446 outPtrWork=std::copy(loc,loc+nbCompo,outPtrWork);
1448 for(mcIdType ig=0;ig<ghostSize;ig++)
1449 outPtrWork=std::copy(inPtr+kk0*nbCompo,inPtr+(kk0+1)*nbCompo,outPtrWork);
1452 kk=fineLocInCoarse[0].first+ghostSize-1+nxwg*(fineLocInCoarse[1].second+ghostSize);
1453 for(mcIdType jg=0;jg<ghostSize;jg++)
1455 for(mcIdType ig=0;ig<ghostSize;ig++)
1456 outPtrWork=std::copy(inPtr+kk*nbCompo,inPtr+(kk+1)*nbCompo,outPtrWork);
1458 for(mcIdType ig=0;ig<dims[0];ig++,kk0++)
1459 for(mcIdType ifact=0;ifact<fact0;ifact++)
1460 outPtrWork=std::copy(inPtr+(kk0)*nbCompo,inPtr+(kk0+1)*nbCompo,outPtrWork);
1461 for(mcIdType ik=0;ik<ghostSize;ik++)
1462 outPtrWork=std::copy(inPtr+kk0*nbCompo,inPtr+(kk0+1)*nbCompo,outPtrWork);
1466 void MEDCouplingIMesh::SpreadCoarseToFineGhostZone2D(const double *inPtr, double *outPtr, std::size_t nbCompo, const std::vector<mcIdType>& coarseSt, const std::vector< std::pair<mcIdType,mcIdType> >& fineLocInCoarse, const std::vector<mcIdType>& facts, mcIdType ghostSize)
1468 double *outPtr2(outPtr);
1469 std::vector<mcIdType> dims(MEDCouplingStructuredMesh::GetDimensionsFromCompactFrmt(fineLocInCoarse));
1470 mcIdType nxwg(coarseSt[0]+2*ghostSize),fact0(facts[0]),fact1(facts[1]);
1471 mcIdType kk(fineLocInCoarse[0].first+ghostSize-1+nxwg*(fineLocInCoarse[1].first+ghostSize-1));//kk is always >=0 thanks to the fact that ghostSize>=1 !
1472 for(mcIdType jg=0;jg<ghostSize;jg++)
1474 for(mcIdType ig=0;ig<ghostSize;ig++)
1475 outPtr2=std::copy(inPtr+kk*nbCompo,inPtr+(kk+1)*nbCompo,outPtr2);
1477 for(mcIdType ig=0;ig<dims[0];ig++,kk0++)
1478 for(mcIdType ifact=0;ifact<fact0;ifact++)
1479 outPtr2=std::copy(inPtr+(kk0)*nbCompo,inPtr+(kk0+1)*nbCompo,outPtr2);
1480 for(mcIdType ik=0;ik<ghostSize;ik++)
1481 outPtr2=std::copy(inPtr+kk0*nbCompo,inPtr+(kk0+1)*nbCompo,outPtr2);
1483 for(mcIdType j=0;j<dims[1];j++)
1485 kk=fineLocInCoarse[0].first-1+ghostSize+nxwg*(fineLocInCoarse[1].first+ghostSize+j);
1486 for(mcIdType jfact=0;jfact<fact1;jfact++)
1488 for(mcIdType ig=0;ig<ghostSize;ig++)
1489 outPtr2=std::copy(inPtr+kk*nbCompo,inPtr+(kk+1)*nbCompo,outPtr2);
1490 mcIdType kk0(kk+1+dims[0]);//1 not ghost. We make the hypothesis that factors is >= ghostlev
1491 outPtr2+=fact0*nbCompo*dims[0];
1492 for(mcIdType ig=0;ig<ghostSize;ig++)
1493 outPtr2=std::copy(inPtr+kk0*nbCompo,inPtr+(kk0+1)*nbCompo,outPtr2);
1496 kk=fineLocInCoarse[0].first+ghostSize-1+nxwg*(fineLocInCoarse[1].second+ghostSize);
1497 for(mcIdType jg=0;jg<ghostSize;jg++)
1499 for(mcIdType ig=0;ig<ghostSize;ig++)
1500 outPtr2=std::copy(inPtr+kk*nbCompo,inPtr+(kk+1)*nbCompo,outPtr2);
1502 for(mcIdType ig=0;ig<dims[0];ig++,kk0++)
1503 for(mcIdType ifact=0;ifact<fact0;ifact++)
1504 outPtr2=std::copy(inPtr+(kk0)*nbCompo,inPtr+(kk0+1)*nbCompo,outPtr2);
1505 for(mcIdType ik=0;ik<ghostSize;ik++)
1506 outPtr2=std::copy(inPtr+kk0*nbCompo,inPtr+(kk0+1)*nbCompo,outPtr2);