-// Copyright (C) 2007-2015 CEA/DEN, EDF R&D
+// Copyright (C) 2007-2016 CEA/DEN, EDF R&D
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
#include "MEDCouplingMappedExtrudedMesh.hxx"
#include "MEDCouplingUMesh.hxx"
+#include "MEDCouplingCMesh.hxx"
#include "MEDCouplingMemArray.hxx"
#include "MEDCouplingFieldDouble.hxx"
#include "MCAuto.hxx"
return new MEDCouplingMappedExtrudedMesh(mesh3D,mesh2D,cell2DId);
}
+MEDCouplingMappedExtrudedMesh *MEDCouplingMappedExtrudedMesh::New(const MEDCouplingCMesh *mesh3D)
+{
+ return new MEDCouplingMappedExtrudedMesh(mesh3D);
+}
+
/*!
* This constructor is here only for unserialisation process.
* This constructor is normally completely useless for end user.
MEDCouplingMappedExtrudedMesh::MEDCouplingMappedExtrudedMesh(const MEDCouplingUMesh *mesh3D, const MEDCouplingUMesh *mesh2D, int cell2DId)
try:_mesh2D(const_cast<MEDCouplingUMesh *>(mesh2D)),_mesh1D(MEDCouplingUMesh::New()),_mesh3D_ids(0),_cell_2D_id(cell2DId)
{
- if(_mesh2D!=0)
+ if(_mesh2D.isNotNull())
_mesh2D->incrRef();
computeExtrusion(mesh3D);
- setName(mesh3D->getName());
+ setName(mesh3D->getName()); setDescription(mesh3D->getDescription());
}
catch(INTERP_KERNEL::Exception& e)
{
- if(_mesh2D)
- _mesh2D->decrRef();
- if(_mesh1D)
- _mesh1D->decrRef();
- if(_mesh3D_ids)
- _mesh3D_ids->decrRef();
throw e;
}
+MEDCouplingMappedExtrudedMesh::MEDCouplingMappedExtrudedMesh(const MEDCouplingCMesh *mesh3D):_mesh1D(MEDCouplingUMesh::New()),_mesh3D_ids(0),_cell_2D_id(0)
+{
+ if(!mesh3D)
+ throw INTERP_KERNEL::Exception("MEDCouplingMappedExtrudedMesh contrct : null input pointer !");
+ if(mesh3D->getMeshDimension()!=3)
+ throw INTERP_KERNEL::Exception("MEDCouplingMappedExtrudedMesh contrct : input cart mesh must have dimension equal to 3 !");
+ MCAuto<MEDCouplingUMesh> umesh3D(mesh3D->buildUnstructured());
+ MCAuto<MEDCouplingCMesh> cmesh2D(MEDCouplingCMesh::New()); cmesh2D->setName(mesh3D->getName());
+ cmesh2D->setCoords(mesh3D->getCoordsAt(0),mesh3D->getCoordsAt(1));
+ _mesh2D=cmesh2D->buildUnstructured();
+ _mesh2D->setCoords(umesh3D->getCoords());
+ computeExtrusion(umesh3D);
+ setName(mesh3D->getName()); setDescription(mesh3D->getDescription());
+}
+
MEDCouplingMappedExtrudedMesh::MEDCouplingMappedExtrudedMesh():_mesh2D(0),_mesh1D(0),_mesh3D_ids(0),_cell_2D_id(-1)
{
}
-MEDCouplingMappedExtrudedMesh::MEDCouplingMappedExtrudedMesh(const MEDCouplingMappedExtrudedMesh& other, bool deepCopy):MEDCouplingMesh(other),_cell_2D_id(other._cell_2D_id)
+MEDCouplingMappedExtrudedMesh::MEDCouplingMappedExtrudedMesh(const MEDCouplingMappedExtrudedMesh& other, bool deepCpy):MEDCouplingMesh(other),_cell_2D_id(other._cell_2D_id)
{
- if(deepCopy)
+ if(deepCpy)
{
_mesh2D=other._mesh2D->clone(true);
_mesh1D=other._mesh1D->clone(true);
else
{
_mesh2D=other._mesh2D;
- if(_mesh2D)
- _mesh2D->incrRef();
_mesh1D=other._mesh1D;
- if(_mesh1D)
- _mesh1D->incrRef();
_mesh3D_ids=other._mesh3D_ids;
- if(_mesh3D_ids)
- _mesh3D_ids->incrRef();
}
}
-int MEDCouplingMappedExtrudedMesh::getNumberOfCells() const
+std::size_t MEDCouplingMappedExtrudedMesh::getNumberOfCells() const
{
return _mesh2D->getNumberOfCells()*_mesh1D->getNumberOfCells();
}
return new MEDCouplingMappedExtrudedMesh(*this,recDeepCpy);
}
+const DataArrayDouble *MEDCouplingMappedExtrudedMesh::getDirectAccessOfCoordsArrIfInStructure() const
+{
+ throw INTERP_KERNEL::Exception("MEDCouplingMappedExtrudedMesh::getDirectAccessOfCoordsArrIfInStructure : no direct access of DataArrayDouble holding nodes !");
+}
+
bool MEDCouplingMappedExtrudedMesh::isEqualIfNotWhy(const MEDCouplingMesh *other, double prec, std::string& reason) const
{
if(!other)
throw INTERP_KERNEL::Exception("MEDCouplingMappedExtrudedMesh::checkDeepEquivalOnSameNodesWith : not implemented yet !");
}
-INTERP_KERNEL::NormalizedCellType MEDCouplingMappedExtrudedMesh::getTypeOfCell(int cellId) const
+INTERP_KERNEL::NormalizedCellType MEDCouplingMappedExtrudedMesh::getTypeOfCell(std::size_t cellId) const
{
- const int *ids=_mesh3D_ids->getConstPointer();
- int nbOf3DCells=_mesh3D_ids->getNumberOfTuples();
- const int *where=std::find(ids,ids+nbOf3DCells,cellId);
+ const int *ids(_mesh3D_ids->begin());
+ std::size_t nbOf3DCells(_mesh3D_ids->getNumberOfTuples());
+ const int *where(std::find(ids,ids+nbOf3DCells,cellId));
if(where==ids+nbOf3DCells)
throw INTERP_KERNEL::Exception("Invalid cellId specified >= getNumberOfCells() !");
- int nbOfCells2D=_mesh2D->getNumberOfCells();
- int locId=((int)std::distance(ids,where))%nbOfCells2D;
- INTERP_KERNEL::NormalizedCellType tmp=_mesh2D->getTypeOfCell(locId);
+ std::size_t nbOfCells2D(_mesh2D->getNumberOfCells());
+ std::size_t locId((std::distance(ids,where))%nbOfCells2D);
+ INTERP_KERNEL::NormalizedCellType tmp(_mesh2D->getTypeOfCell(locId));
return INTERP_KERNEL::CellModel::GetCellModel(tmp).getExtrudedType();
}
DataArrayInt *MEDCouplingMappedExtrudedMesh::giveCellsWithType(INTERP_KERNEL::NormalizedCellType type) const
{
- const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(type);
- INTERP_KERNEL::NormalizedCellType revExtTyp=cm.getReverseExtrudedType();
- MCAuto<DataArrayInt> ret=DataArrayInt::New();
+ const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel(type));
+ INTERP_KERNEL::NormalizedCellType revExtTyp(cm.getReverseExtrudedType());
+ MCAuto<DataArrayInt> ret(DataArrayInt::New());
if(revExtTyp==INTERP_KERNEL::NORM_ERROR)
{
ret->alloc(0,1);
return ret.retn();
}
- MCAuto<DataArrayInt> tmp=_mesh2D->giveCellsWithType(revExtTyp);
- int nbOfLevs=_mesh1D->getNumberOfCells();
- int nbOfCells2D=_mesh2D->getNumberOfCells();
- int nbOfTuples=tmp->getNumberOfTuples();
+ MCAuto<DataArrayInt> tmp(_mesh2D->giveCellsWithType(revExtTyp));
+ int nbOfLevs(_mesh1D->getNumberOfCells());
+ int nbOfCells2D(_mesh2D->getNumberOfCells());
+ int nbOfTuples(tmp->getNumberOfTuples());
ret->alloc(nbOfLevs*nbOfTuples,1);
- int *pt=ret->getPointer();
+ int *pt(ret->getPointer());
for(int i=0;i<nbOfLevs;i++,pt+=nbOfTuples)
std::transform(tmp->begin(),tmp->end(),pt,std::bind2nd(std::plus<int>(),i*nbOfCells2D));
- MCAuto<DataArrayInt> ret2=ret->renumberR(_mesh3D_ids->begin());
+ MCAuto<DataArrayInt> ret2(ret->renumberR(_mesh3D_ids->begin()));
ret2->sort();
return ret2.retn();
}
DataArrayInt *MEDCouplingMappedExtrudedMesh::computeNbOfNodesPerCell() const
{
- MCAuto<DataArrayInt> ret2D=_mesh2D->computeNbOfNodesPerCell();
- int nbOfLevs=_mesh1D->getNumberOfCells();
- int nbOfCells2D=_mesh2D->getNumberOfCells();
- MCAuto<DataArrayInt> ret3D=DataArrayInt::New(); ret3D->alloc(nbOfLevs*nbOfCells2D,1);
- int *pt=ret3D->getPointer();
+ MCAuto<DataArrayInt> ret2D(_mesh2D->computeNbOfNodesPerCell());
+ int nbOfLevs(_mesh1D->getNumberOfCells());
+ int nbOfCells2D(_mesh2D->getNumberOfCells());
+ MCAuto<DataArrayInt> ret3D(DataArrayInt::New()); ret3D->alloc(nbOfLevs*nbOfCells2D,1);
+ int *pt(ret3D->getPointer());
for(int i=0;i<nbOfLevs;i++,pt+=nbOfCells2D)
std::copy(ret2D->begin(),ret2D->end(),pt);
ret3D->applyLin(2,0,0);
DataArrayInt *MEDCouplingMappedExtrudedMesh::computeNbOfFacesPerCell() const
{
- MCAuto<DataArrayInt> ret2D=_mesh2D->computeNbOfNodesPerCell();
- int nbOfLevs=_mesh1D->getNumberOfCells();
- int nbOfCells2D=_mesh2D->getNumberOfCells();
- MCAuto<DataArrayInt> ret3D=DataArrayInt::New(); ret3D->alloc(nbOfLevs*nbOfCells2D,1);
- int *pt=ret3D->getPointer();
+ MCAuto<DataArrayInt> ret2D(_mesh2D->computeNbOfNodesPerCell());
+ int nbOfLevs(_mesh1D->getNumberOfCells());
+ int nbOfCells2D(_mesh2D->getNumberOfCells());
+ MCAuto<DataArrayInt> ret3D(DataArrayInt::New()); ret3D->alloc(nbOfLevs*nbOfCells2D,1);
+ int *pt(ret3D->getPointer());
for(int i=0;i<nbOfLevs;i++,pt+=nbOfCells2D)
std::copy(ret2D->begin(),ret2D->end(),pt);
ret3D->applyLin(2,2,0);
return computeNbOfNodesPerCell();
}
-int MEDCouplingMappedExtrudedMesh::getNumberOfCellsWithType(INTERP_KERNEL::NormalizedCellType type) const
+std::size_t MEDCouplingMappedExtrudedMesh::getNumberOfCellsWithType(INTERP_KERNEL::NormalizedCellType type) const
{
- int ret=0;
- int nbOfCells2D=_mesh2D->getNumberOfCells();
- for(int i=0;i<nbOfCells2D;i++)
+ std::size_t ret(0);
+ std::size_t nbOfCells2D(_mesh2D->getNumberOfCells());
+ for(std::size_t i=0;i<nbOfCells2D;i++)
{
- INTERP_KERNEL::NormalizedCellType t=_mesh2D->getTypeOfCell(i);
+ INTERP_KERNEL::NormalizedCellType t(_mesh2D->getTypeOfCell(i));
if(INTERP_KERNEL::CellModel::GetCellModel(t).getExtrudedType()==type)
ret++;
}
return ret*_mesh1D->getNumberOfCells();
}
-void MEDCouplingMappedExtrudedMesh::getNodeIdsOfCell(int cellId, std::vector<int>& conn) const
+void MEDCouplingMappedExtrudedMesh::getNodeIdsOfCell(std::size_t cellId, std::vector<int>& conn) const
{
- int nbOfCells2D=_mesh2D->getNumberOfCells();
- int nbOfNodes2D=_mesh2D->getNumberOfNodes();
- int locId=cellId%nbOfCells2D;
- int lev=cellId/nbOfCells2D;
+ int nbOfCells2D(_mesh2D->getNumberOfCells());
+ int nbOfNodes2D(_mesh2D->getNumberOfNodes());
+ int locId(cellId%nbOfCells2D);
+ int lev(cellId/nbOfCells2D);
std::vector<int> tmp,tmp2;
_mesh2D->getNodeIdsOfCell(locId,tmp);
tmp2=tmp;
void MEDCouplingMappedExtrudedMesh::getCoordinatesOfNode(int nodeId, std::vector<double>& coo) const
{
- int nbOfNodes2D=_mesh2D->getNumberOfNodes();
- int locId=nodeId%nbOfNodes2D;
- int lev=nodeId/nbOfNodes2D;
+ int nbOfNodes2D(_mesh2D->getNumberOfNodes());
+ int locId(nodeId%nbOfNodes2D);
+ int lev(nodeId/nbOfNodes2D);
std::vector<double> tmp,tmp2;
_mesh2D->getCoordinatesOfNode(locId,tmp);
tmp2=tmp;
- int spaceDim=_mesh1D->getSpaceDimension();
- const double *z=_mesh1D->getCoords()->getConstPointer();
+ int spaceDim(_mesh1D->getSpaceDimension());
+ const double *z(_mesh1D->getCoords()->begin());
std::transform(tmp.begin(),tmp.end(),z+lev*spaceDim,tmp.begin(),std::plus<double>());
std::transform(tmp2.begin(),tmp2.end(),z+(lev+1)*spaceDim,tmp2.begin(),std::plus<double>());
coo.insert(coo.end(),tmp.begin(),tmp.end());
{
double bbox2D[6];
_mesh2D->getBoundingBox(bbox2D);
- const double *nodes1D=_mesh1D->getCoords()->getConstPointer();
- int nbOfNodes1D=_mesh1D->getNumberOfNodes();
+ const double *nodes1D(_mesh1D->getCoords()->begin());
+ int nbOfNodes1D(_mesh1D->getNumberOfNodes());
double bbox1DMin[3],bbox1DMax[3],tmp[3];
std::fill(bbox1DMin,bbox1DMin+3,std::numeric_limits<double>::max());
std::fill(bbox1DMax,bbox1DMax+3,-(std::numeric_limits<double>::max()));
void MEDCouplingMappedExtrudedMesh::updateTime() const
{
- if(_mesh2D)
- {
- updateTimeWith(*_mesh2D);
- }
- if(_mesh1D)
- {
- updateTimeWith(*_mesh1D);
- }
+ if(_mesh2D.isNotNull())
+ updateTimeWith(*_mesh2D);
+ if(_mesh1D.isNotNull())
+ updateTimeWith(*_mesh1D);
}
void MEDCouplingMappedExtrudedMesh::renumberCells(const int *old2NewBg, bool check)
{
- throw INTERP_KERNEL::Exception("Functionnality of renumbering cells unavailable for ExtrudedMesh");
+ throw INTERP_KERNEL::Exception("Functionality of renumbering cells unavailable for ExtrudedMesh");
}
+/*!
+ * \b WARNING in case of modif think to update MEDFileUMesh::New implementation !
+ * \sa MEDFileUMesh::New
+ */
MEDCouplingUMesh *MEDCouplingMappedExtrudedMesh::build3DUnstructuredMesh() const
{
- MEDCouplingUMesh *ret=_mesh2D->buildExtrudedMesh(_mesh1D,0);
- const int *renum=_mesh3D_ids->getConstPointer();
+ MCAuto<MEDCouplingUMesh> mesh2DZC(_mesh2D->deepCopyConnectivityOnly());
+ mesh2DZC->zipCoords();
+ MCAuto<MEDCouplingUMesh> ret(mesh2DZC->buildExtrudedMesh(_mesh1D,0));
+ const int *renum(_mesh3D_ids->begin());
ret->renumberCells(renum,false);
ret->setName(getName());
- return ret;
+ return ret.retn();
}
+/*!
+ * \b WARNING in case of modif think to update MEDFileUMesh::New implementation !
+ * \sa MEDFileUMesh::New
+ */
MEDCouplingUMesh *MEDCouplingMappedExtrudedMesh::buildUnstructured() const
{
return build3DUnstructuredMesh();
{
std::string name="MeasureOfMesh_";
name+=getName();
- MEDCouplingFieldDouble *ret2D=_mesh2D->getMeasureField(true);
- MEDCouplingFieldDouble *ret1D=_mesh1D->getMeasureField(true);
- const double *ret2DPtr=ret2D->getArray()->getConstPointer();
- const double *ret1DPtr=ret1D->getArray()->getConstPointer();
- int nbOf2DCells=_mesh2D->getNumberOfCells();
- int nbOf1DCells=_mesh1D->getNumberOfCells();
- int nbOf3DCells=nbOf2DCells*nbOf1DCells;
- const int *renum=_mesh3D_ids->getConstPointer();
- MEDCouplingFieldDouble *ret=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
+ MCAuto<MEDCouplingFieldDouble> ret2D(_mesh2D->getMeasureField(true)),ret1D(_mesh1D->getMeasureField(true));
+ const double *ret2DPtr(ret2D->getArray()->begin());
+ const double *ret1DPtr(ret1D->getArray()->begin());
+ int nbOf2DCells(_mesh2D->getNumberOfCells()),nbOf1DCells(_mesh1D->getNumberOfCells()),nbOf3DCells(nbOf2DCells*nbOf1DCells);
+ const int *renum(_mesh3D_ids->begin());
+ MCAuto<MEDCouplingFieldDouble> ret(MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME));
ret->setMesh(this);
ret->synchronizeTimeWithMesh();
- DataArrayDouble *da=DataArrayDouble::New();
+ MCAuto<DataArrayDouble> da(DataArrayDouble::New());
da->alloc(nbOf3DCells,1);
- double *retPtr=da->getPointer();
+ double *retPtr(da->getPointer());
for(int i=0;i<nbOf1DCells;i++)
for(int j=0;j<nbOf2DCells;j++)
retPtr[renum[i*nbOf2DCells+j]]=ret2DPtr[j]*ret1DPtr[i];
ret->setArray(da);
- da->decrRef();
ret->setName(name);
- ret2D->decrRef();
- ret1D->decrRef();
- return ret;
+ return ret.retn();
}
MEDCouplingFieldDouble *MEDCouplingMappedExtrudedMesh::getMeasureFieldOnNode(bool isAbs) const
throw INTERP_KERNEL::Exception("MEDCouplingMappedExtrudedMesh::getCellContainingPoint : not implemented yet !");
}
+void MEDCouplingMappedExtrudedMesh::getCellsContainingPoint(const double *pos, double eps, std::vector<int>& elts) const
+{
+ throw INTERP_KERNEL::Exception("MEDCouplingMappedExtrudedMesh::getCellsContainingPoint : not implemented yet !");
+}
+
MEDCouplingMappedExtrudedMesh::~MEDCouplingMappedExtrudedMesh()
{
- if(_mesh2D)
- _mesh2D->decrRef();
- if(_mesh1D)
- _mesh1D->decrRef();
- if(_mesh3D_ids)
- _mesh3D_ids->decrRef();
}
void MEDCouplingMappedExtrudedMesh::computeExtrusion(const MEDCouplingUMesh *mesh3D)
const char errMsg1[]="2D mesh is empty unable to compute extrusion !";
const char errMsg2[]="Coords between 2D and 3D meshes are not the same ! Try MEDCouplingPointSet::tryToShareSameCoords method";
const char errMsg3[]="No chance to find extrusion pattern in mesh3D,mesh2D couple because nbCells3D%nbCells2D!=0 !";
- if(_mesh2D==0 || mesh3D==0)
+ if(_mesh2D.isNull() || mesh3D==0)
throw INTERP_KERNEL::Exception(errMsg1);
if(_mesh2D->getCoords()!=mesh3D->getCoords())
throw INTERP_KERNEL::Exception(errMsg2);
if(mesh3D->getNumberOfCells()%_mesh2D->getNumberOfCells()!=0)
throw INTERP_KERNEL::Exception(errMsg3);
- if(!_mesh3D_ids)
+ if(_mesh3D_ids.isNull())
_mesh3D_ids=DataArrayInt::New();
- if(!_mesh1D)
+ if(_mesh1D.isNull())
_mesh1D=MEDCouplingUMesh::New();
computeExtrusionAlg(mesh3D);
}
const int *revDesc3D, const int *revDescIndx3D,
bool computeMesh1D)
{
- int nbOf2DCells=_mesh2D->getNumberOfCells();
- int start=revDescIndx3D[idIn3DDesc];
- int end=revDescIndx3D[idIn3DDesc+1];
+ int nbOf2DCells(_mesh2D->getNumberOfCells());
+ int start(revDescIndx3D[idIn3DDesc]);
+ int end(revDescIndx3D[idIn3DDesc+1]);
if(end-start!=1)
{
std::ostringstream ost; ost << "Invalid bases 2D mesh specified : 2D cell # " << idIn3DDesc;
ost << " shared by more than 1 3D cell !!!";
throw INTERP_KERNEL::Exception(ost.str().c_str());
}
- int current3DCell=revDesc3D[start];
- int current2DCell=idIn3DDesc;
- int *mesh3DIDs=_mesh3D_ids->getPointer();
+ int current3DCell(revDesc3D[start]);
+ int current2DCell(idIn3DDesc);
+ int *mesh3DIDs(_mesh3D_ids->getPointer());
mesh3DIDs[newId]=current3DCell;
- const int *conn2D=subMesh->getNodalConnectivity()->getConstPointer();
- const int *conn2DIndx=subMesh->getNodalConnectivityIndex()->getConstPointer();
+ const int *conn2D(subMesh->getNodalConnectivity()->begin());
+ const int *conn2DIndx(subMesh->getNodalConnectivityIndex()->begin());
for(int i=1;i<nbOf1DLev;i++)
{
std::vector<int> conn(conn2D+conn2DIndx[current2DCell]+1,conn2D+conn2DIndx[current2DCell+1]);
const int *desc3D, const int *descIndx3D,
const int *conn2D, const int *conn2DIndx)
{
- int start=descIndx3D[current3DCell];
- int end=descIndx3D[current3DCell+1];
+ int start(descIndx3D[current3DCell]);
+ int end(descIndx3D[current3DCell+1]);
bool found=false;
for(const int *candidate2D=desc3D+start;candidate2D!=desc3D+end && !found;candidate2D++)
{
void MEDCouplingMappedExtrudedMesh::computeBaryCenterOfFace(const std::vector<int>& nodalConnec, int lev1DId)
{
- double *zoneToUpdate=_mesh1D->getCoords()->getPointer()+lev1DId*3;
+ double *zoneToUpdate(_mesh1D->getCoords()->getPointer()+lev1DId*3);
std::fill(zoneToUpdate,zoneToUpdate+3,0.);
- const double *coords=_mesh2D->getCoords()->getConstPointer();
+ const double *coords(_mesh2D->getCoords()->begin());
for(std::vector<int>::const_iterator iter=nodalConnec.begin();iter!=nodalConnec.end();iter++)
std::transform(zoneToUpdate,zoneToUpdate+3,coords+3*(*iter),zoneToUpdate,std::plus<double>());
std::transform(zoneToUpdate,zoneToUpdate+3,zoneToUpdate,std::bind2nd(std::multiplies<double>(),(double)(1./(int)nodalConnec.size())));
throw INTERP_KERNEL::Exception("Not implemented yet !");
}
-void MEDCouplingMappedExtrudedMesh::splitProfilePerType(const DataArrayInt *profile, std::vector<int>& code, std::vector<DataArrayInt *>& idsInPflPerType, std::vector<DataArrayInt *>& idsPerType) const
+void MEDCouplingMappedExtrudedMesh::splitProfilePerType(const DataArrayInt *profile, std::vector<int>& code, std::vector<DataArrayInt *>& idsInPflPerType, std::vector<DataArrayInt *>& idsPerType, bool smartPflKiller) const
{
throw INTERP_KERNEL::Exception("Not implemented yet !");
}
DataArrayDouble *MEDCouplingMappedExtrudedMesh::getCoordinatesAndOwner() const
{
- DataArrayDouble *arr2D=_mesh2D->getCoords();
- DataArrayDouble *arr1D=_mesh1D->getCoords();
- DataArrayDouble *ret=DataArrayDouble::New();
+ const DataArrayDouble *arr2D(_mesh2D->getCoords());
+ const DataArrayDouble *arr1D(_mesh1D->getCoords());
+ MCAuto<DataArrayDouble> ret(DataArrayDouble::New());
ret->alloc(getNumberOfNodes(),3);
- int nbOf1DLev=_mesh1D->getNumberOfNodes();
- int nbOf2DNodes=_mesh2D->getNumberOfNodes();
- const double *ptSrc=arr2D->getConstPointer();
- double *pt=ret->getPointer();
+ int nbOf1DLev(_mesh1D->getNumberOfNodes());
+ int nbOf2DNodes(_mesh2D->getNumberOfNodes());
+ const double *ptSrc(arr2D->begin());
+ double *pt(ret->getPointer());
std::copy(ptSrc,ptSrc+3*nbOf2DNodes,pt);
for(int i=1;i<nbOf1DLev;i++)
{
std::copy(ptSrc,ptSrc+3*nbOf2DNodes,pt+3*i*nbOf2DNodes);
double vec[3];
- std::copy(arr1D->getConstPointer()+3*i,arr1D->getConstPointer()+3*(i+1),vec);
- std::transform(arr1D->getConstPointer()+3*(i-1),arr1D->getConstPointer()+3*i,vec,vec,std::minus<double>());
+ std::copy(arr1D->begin()+3*i,arr1D->begin()+3*(i+1),vec);
+ std::transform(arr1D->begin()+3*(i-1),arr1D->begin()+3*i,vec,vec,std::minus<double>());
for(int j=0;j<nbOf2DNodes;j++)
std::transform(vec,vec+3,pt+3*(i*nbOf2DNodes+j),pt+3*(i*nbOf2DNodes+j),std::plus<double>());
}
- return ret;
+ return ret.retn();
}
DataArrayDouble *MEDCouplingMappedExtrudedMesh::computeCellCenterOfMass() const
void MEDCouplingMappedExtrudedMesh::computeExtrusionAlg(const MEDCouplingUMesh *mesh3D)
{
_mesh3D_ids->alloc(mesh3D->getNumberOfCells(),1);
- int nbOf1DLev=mesh3D->getNumberOfCells()/_mesh2D->getNumberOfCells();
+ int nbOf1DLev(mesh3D->getNumberOfCells()/_mesh2D->getNumberOfCells());
_mesh1D->setMeshDimension(1);
_mesh1D->allocateCells(nbOf1DLev);
int tmpConn[2];
myCoords->alloc(nbOf1DLev+1,3);
_mesh1D->setCoords(myCoords);
myCoords->decrRef();
- DataArrayInt *desc,*descIndx,*revDesc,*revDescIndx;
- desc=DataArrayInt::New(); descIndx=DataArrayInt::New(); revDesc=DataArrayInt::New(); revDescIndx=DataArrayInt::New();
- MEDCouplingUMesh *subMesh=mesh3D->buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
- DataArrayInt *revNodal2D,*revNodalIndx2D;
- revNodal2D=DataArrayInt::New(); revNodalIndx2D=DataArrayInt::New();
+ MCAuto<DataArrayInt> desc(DataArrayInt::New()),descIndx(DataArrayInt::New()),revDesc(DataArrayInt::New()),revDescIndx(DataArrayInt::New());
+ MCAuto<MEDCouplingUMesh> subMesh(mesh3D->buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx));
+ MCAuto<DataArrayInt> revNodal2D(DataArrayInt::New()),revNodalIndx2D(DataArrayInt::New());
subMesh->getReverseNodalConnectivity(revNodal2D,revNodalIndx2D);
- const int *nodal2D=_mesh2D->getNodalConnectivity()->getConstPointer();
- const int *nodal2DIndx=_mesh2D->getNodalConnectivityIndex()->getConstPointer();
- const int *revNodal2DPtr=revNodal2D->getConstPointer();
- const int *revNodalIndx2DPtr=revNodalIndx2D->getConstPointer();
- const int *descP=desc->getConstPointer();
- const int *descIndxP=descIndx->getConstPointer();
- const int *revDescP=revDesc->getConstPointer();
- const int *revDescIndxP=revDescIndx->getConstPointer();
+ const int *nodal2D(_mesh2D->getNodalConnectivity()->begin());
+ const int *nodal2DIndx(_mesh2D->getNodalConnectivityIndex()->begin());
+ const int *revNodal2DPtr(revNodal2D->begin());
+ const int *revNodalIndx2DPtr(revNodalIndx2D->begin());
+ const int *descP(desc->begin()),*descIndxP(descIndx->begin()),*revDescP(revDesc->begin()),*revDescIndxP(revDescIndx->begin());
//
- int nbOf2DCells=_mesh2D->getNumberOfCells();
+ int nbOf2DCells(_mesh2D->getNumberOfCells());
for(int i=0;i<nbOf2DCells;i++)
{
int idInSubMesh;
}
build1DExtrusion(idInSubMesh,i,nbOf1DLev,subMesh,descP,descIndxP,revDescP,revDescIndxP,i==_cell_2D_id);
}
- //
- revNodal2D->decrRef();
- revNodalIndx2D->decrRef();
- subMesh->decrRef();
- desc->decrRef();
- descIndx->decrRef();
- revDesc->decrRef();
- revDescIndx->decrRef();
}
void MEDCouplingMappedExtrudedMesh::getTinySerializationInformation(std::vector<double>& tinyInfoD, std::vector<int>& tinyInfo, std::vector<std::string>& littleStrings) const
_mesh1D->serialize(a1_2,a2_2);
a1->alloc(a1_1->getNbOfElems()+a1_2->getNbOfElems()+_mesh3D_ids->getNbOfElems(),1);
int *ptri=a1->getPointer();
- ptri=std::copy(a1_1->getConstPointer(),a1_1->getConstPointer()+a1_1->getNbOfElems(),ptri);
+ ptri=std::copy(a1_1->begin(),a1_1->begin()+a1_1->getNbOfElems(),ptri);
a1_1->decrRef();
- ptri=std::copy(a1_2->getConstPointer(),a1_2->getConstPointer()+a1_2->getNbOfElems(),ptri);
+ ptri=std::copy(a1_2->begin(),a1_2->begin()+a1_2->getNbOfElems(),ptri);
a1_2->decrRef();
- std::copy(_mesh3D_ids->getConstPointer(),_mesh3D_ids->getConstPointer()+_mesh3D_ids->getNbOfElems(),ptri);
+ std::copy(_mesh3D_ids->begin(),_mesh3D_ids->begin()+_mesh3D_ids->getNbOfElems(),ptri);
a2->alloc(a2_1->getNbOfElems()+a2_2->getNbOfElems(),1);
double *ptrd=a2->getPointer();
- ptrd=std::copy(a2_1->getConstPointer(),a2_1->getConstPointer()+a2_1->getNbOfElems(),ptrd);
+ ptrd=std::copy(a2_1->begin(),a2_1->begin()+a2_1->getNbOfElems(),ptrd);
a2_1->decrRef();
- std::copy(a2_2->getConstPointer(),a2_2->getConstPointer()+a2_2->getNbOfElems(),ptrd);
+ std::copy(a2_2->begin(),a2_2->begin()+a2_2->getNbOfElems(),ptrd);
a2_2->decrRef();
}
std::vector<int> ti2(tinyInfo.begin()+sz1,tinyInfo.end()-3);
DataArrayInt *a1tmp=DataArrayInt::New();
DataArrayDouble *a2tmp=DataArrayDouble::New();
- const int *a1Ptr=a1->getConstPointer();
- const double *a2Ptr=a2->getConstPointer();
+ const int *a1Ptr=a1->begin();
+ const double *a2Ptr=a2->begin();
_mesh2D=MEDCouplingUMesh::New();
std::vector<std::string> ls1,ls2;
_mesh2D->resizeForUnserialization(ti1,a1tmp,a2tmp,ls1);
a1tmp->decrRef(); a2tmp->decrRef();
//
_mesh3D_ids=DataArrayInt::New();
- int szIds=(int)std::distance(a1Ptr,a1->getConstPointer()+a1->getNbOfElems());
+ int szIds=(int)std::distance(a1Ptr,a1->begin()+a1->getNbOfElems());
_mesh3D_ids->alloc(szIds,1);
std::copy(a1Ptr,a1Ptr+szIds,_mesh3D_ids->getPointer());
}
