-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D
+// Copyright (C) 2007-2019 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
/// @cond INTERNAL
const INTERP_KERNEL::NormalizedCellType MEDCouplingUMesh::MEDMEM_ORDER[N_MEDMEM_ORDER] = { INTERP_KERNEL::NORM_POINT1, INTERP_KERNEL::NORM_SEG2, INTERP_KERNEL::NORM_SEG3, INTERP_KERNEL::NORM_SEG4, INTERP_KERNEL::NORM_POLYL, INTERP_KERNEL::NORM_TRI3, INTERP_KERNEL::NORM_QUAD4, INTERP_KERNEL::NORM_TRI6, INTERP_KERNEL::NORM_TRI7, INTERP_KERNEL::NORM_QUAD8, INTERP_KERNEL::NORM_QUAD9, INTERP_KERNEL::NORM_POLYGON, INTERP_KERNEL::NORM_QPOLYG, INTERP_KERNEL::NORM_TETRA4, INTERP_KERNEL::NORM_PYRA5, INTERP_KERNEL::NORM_PENTA6, INTERP_KERNEL::NORM_HEXA8, INTERP_KERNEL::NORM_HEXGP12, INTERP_KERNEL::NORM_TETRA10, INTERP_KERNEL::NORM_PYRA13, INTERP_KERNEL::NORM_PENTA15, INTERP_KERNEL::NORM_PENTA18, INTERP_KERNEL::NORM_HEXA20, INTERP_KERNEL::NORM_HEXA27, INTERP_KERNEL::NORM_POLYHED };
-const int MEDCouplingUMesh::MEDCOUPLING2VTKTYPETRADUCER[INTERP_KERNEL::NORM_MAXTYPE+1]={1,3,21,5,9,7,22,34,23,28,-1,-1,-1,-1,10,14,13,-1,12,-1,24,-1,16,27,-1,26,-1,29,32,-1,25,42,36,4};
+const mcIdType MEDCouplingUMesh::MEDCOUPLING2VTKTYPETRADUCER[INTERP_KERNEL::NORM_MAXTYPE+1]={1,3,21,5,9,7,22,34,23,28,-1,-1,-1,-1,10,14,13,-1,12,-1,24,-1,16,27,-1,26,-1,29,32,-1,25,42,36,4};
/// @endcond
MEDCouplingUMesh *MEDCouplingUMesh::New()
* Returns a new MEDCouplingUMesh which is a full copy of \a this one. No data is shared
* between \a this and the new mesh.
* \return MEDCouplingUMesh * - a new instance of MEDCouplingMesh. The caller is to
- * delete this mesh using decrRef() as it is no more needed.
+ * delete this mesh using decrRef() as it is no more needed.
*/
MEDCouplingUMesh *MEDCouplingUMesh::deepCopy() const
{
* \param [in] recDeepCpy - if \a true, the copy is deep, else all data arrays of \a
* this mesh are shared by the new mesh.
* \return MEDCouplingUMesh * - a new instance of MEDCouplingMesh. The caller is to
- * delete this mesh using decrRef() as it is no more needed.
+ * delete this mesh using decrRef() as it is no more needed.
*/
MEDCouplingUMesh *MEDCouplingUMesh::clone(bool recDeepCpy) const
{
/*!
* This method behaves mostly like MEDCouplingUMesh::deepCopy method, except that only nodal connectivity arrays are deeply copied.
* The coordinates are shared between \a this and the returned instance.
- *
+ *
* \return MEDCouplingUMesh * - A new object instance holding the copy of \a this (deep for connectivity, shallow for coordiantes)
* \sa MEDCouplingUMesh::deepCopy
*/
{
checkConnectivityFullyDefined();
MCAuto<MEDCouplingUMesh> ret=clone(false);
- MCAuto<DataArrayInt> c(getNodalConnectivity()->deepCopy()),ci(getNodalConnectivityIndex()->deepCopy());
+ MCAuto<DataArrayIdType> c(getNodalConnectivity()->deepCopy()),ci(getNodalConnectivityIndex()->deepCopy());
ret->setConnectivity(c,ci);
return ret.retn();
}
MEDCouplingPointSet::checkConsistencyLight();
for(std::set<INTERP_KERNEL::NormalizedCellType>::const_iterator iter=_types.begin();iter!=_types.end();iter++)
{
- if((int)INTERP_KERNEL::CellModel::GetCellModel(*iter).getDimension()!=_mesh_dim)
+ if(ToIdType(INTERP_KERNEL::CellModel::GetCellModel(*iter).getDimension())!=_mesh_dim)
{
std::ostringstream message;
message << "Mesh invalid because dimension is " << _mesh_dim << " and there is presence of cell(s) with type " << (*iter);
if(_mesh_dim==-1)
return ;
int meshDim=getMeshDimension();
- int nbOfNodes=getNumberOfNodes();
- int nbOfCells=getNumberOfCells();
- const int *ptr=_nodal_connec->getConstPointer();
- const int *ptrI=_nodal_connec_index->getConstPointer();
- for(int i=0;i<nbOfCells;i++)
+ mcIdType nbOfNodes=getNumberOfNodes();
+ mcIdType nbOfCells=getNumberOfCells();
+ const mcIdType *ptr=_nodal_connec->getConstPointer();
+ const mcIdType *ptrI=_nodal_connec_index->getConstPointer();
+ for(mcIdType i=0;i<nbOfCells;i++)
{
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel((INTERP_KERNEL::NormalizedCellType)ptr[ptrI[i]]);
- if((int)cm.getDimension()!=meshDim)
+ if(ToIdType(cm.getDimension())!=meshDim)
{
std::ostringstream oss;
oss << "MEDCouplingUMesh::checkConsistency : cell << #" << i<< " with type Type " << cm.getRepr() << " in 'this' whereas meshdim == " << meshDim << " !";
throw INTERP_KERNEL::Exception(oss.str());
}
- int nbOfNodesInCell=ptrI[i+1]-ptrI[i]-1;
+ mcIdType nbOfNodesInCell=ptrI[i+1]-ptrI[i]-1;
if(!cm.isDynamic())
- if(nbOfNodesInCell!=(int)cm.getNumberOfNodes())
+ if(nbOfNodesInCell!=ToIdType(cm.getNumberOfNodes()))
{
std::ostringstream oss;
oss << "MEDCouplingUMesh::checkConsistency : cell #" << i << " with static Type '" << cm.getRepr() << "' has " << cm.getNumberOfNodes();
oss << " nodes. This should be even, and greater or equal than 4!! Looks very bad!";
throw INTERP_KERNEL::Exception(oss.str());
}
- for(const int *w=ptr+ptrI[i]+1;w!=ptr+ptrI[i+1];w++)
+ for(const mcIdType *w=ptr+ptrI[i]+1;w!=ptr+ptrI[i+1];w++)
{
- int nodeId=*w;
+ mcIdType nodeId=*w;
if(nodeId>=0)
{
if(nodeId>=nbOfNodes)
}
/*!
- * Allocates memory to store an estimation of the given number of cells.
+ * Allocates memory to store an estimation of the given number of cells.
* The closer the estimation to the number of cells effectively inserted, the less need the library requires
* to reallocate memory. If the number of cells to be inserted is not known simply assign 0 to this parameter.
* If a nodal connectivity previously existed before the call of this method, it will be reset.
* \ref medcouplingpyexamplesUmeshStdBuild1 "Here is a Python example".
* \endif
*/
-void MEDCouplingUMesh::allocateCells(int nbOfCells)
+void MEDCouplingUMesh::allocateCells(mcIdType nbOfCells)
{
if(nbOfCells<0)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::allocateCells : the input number of cells should be >= 0 !");
{
_nodal_connec->decrRef();
}
- _nodal_connec_index=DataArrayInt::New();
+ _nodal_connec_index=DataArrayIdType::New();
_nodal_connec_index->reserve(nbOfCells+1);
_nodal_connec_index->pushBackSilent(0);
- _nodal_connec=DataArrayInt::New();
+ _nodal_connec=DataArrayIdType::New();
_nodal_connec->reserve(2*nbOfCells);
_types.clear();
declareAsNew();
* \param [in] type - type of cell to add.
* \param [in] size - number of nodes constituting this cell.
* \param [in] nodalConnOfCell - the connectivity of the cell to add.
- *
+ *
* \if ENABLE_EXAMPLES
* \ref medcouplingcppexamplesUmeshStdBuild1 "Here is a C++ example".<br>
* \ref medcouplingpyexamplesUmeshStdBuild1 "Here is a Python example".
* \endif
*/
-void MEDCouplingUMesh::insertNextCell(INTERP_KERNEL::NormalizedCellType type, int size, const int *nodalConnOfCell)
+void MEDCouplingUMesh::insertNextCell(INTERP_KERNEL::NormalizedCellType type, mcIdType size, const mcIdType *nodalConnOfCell)
{
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(type);
if(_nodal_connec_index==0)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::insertNextCell : nodal connectivity not set ! invoke allocateCells before calling insertNextCell !");
- if((int)cm.getDimension()==_mesh_dim)
+ if(ToIdType(cm.getDimension())==_mesh_dim)
{
if(!cm.isDynamic())
- if(size!=(int)cm.getNumberOfNodes())
+ if(size!=ToIdType(cm.getNumberOfNodes()))
{
std::ostringstream oss; oss << "MEDCouplingUMesh::insertNextCell : Trying to push a " << cm.getRepr() << " cell with a size of " << size;
oss << " ! Expecting " << cm.getNumberOfNodes() << " !";
throw INTERP_KERNEL::Exception(oss.str());
}
- int idx=_nodal_connec_index->back();
- int val=idx+size+1;
+ mcIdType idx=_nodal_connec_index->back();
+ mcIdType val=idx+size+1;
_nodal_connec_index->pushBackSilent(val);
_nodal_connec->writeOnPlace(idx,type,nodalConnOfCell,size);
_types.insert(type);
/*!
* Compacts data arrays to release unused memory. This method is to be called after
* finishing cell insertion using \a this->insertNextCell().
- *
+ *
* \if ENABLE_EXAMPLES
* \ref medcouplingcppexamplesUmeshStdBuild1 "Here is a C++ example".<br>
* \ref medcouplingpyexamplesUmeshStdBuild1 "Here is a Python example".
* having the same geometric type. So a same geometric type can appear more than once if the cells are not sorted per geometric type.
*
* \throw if connectivity in \a this is not correctly defined.
- *
+ *
* \sa MEDCouplingMesh::getAllGeoTypes
*/
std::vector<INTERP_KERNEL::NormalizedCellType> MEDCouplingUMesh::getAllGeoTypesSorted() const
{
std::vector<INTERP_KERNEL::NormalizedCellType> ret;
checkConnectivityFullyDefined();
- int nbOfCells(getNumberOfCells());
+ mcIdType nbOfCells=getNumberOfCells();
if(nbOfCells==0)
return ret;
if(getNodalConnectivityArrayLen()<1)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::getAllGeoTypesSorted : the connectivity in this seems invalid !");
- const int *c(_nodal_connec->begin()),*ci(_nodal_connec_index->begin());
+ const mcIdType *c(_nodal_connec->begin()),*ci(_nodal_connec_index->begin());
ret.push_back((INTERP_KERNEL::NormalizedCellType)c[*ci++]);
- for(int i=1;i<nbOfCells;i++,ci++)
+ for(mcIdType i=1;i<nbOfCells;i++,ci++)
if(ret.back()!=((INTERP_KERNEL::NormalizedCellType)c[*ci]))
ret.push_back((INTERP_KERNEL::NormalizedCellType)c[*ci]);
return ret;
MEDCouplingPointSet::checkFastEquivalWith(other,prec);
const MEDCouplingUMesh *otherC=dynamic_cast<const MEDCouplingUMesh *>(other);
if(!otherC)
- throw INTERP_KERNEL::Exception("MEDCouplingUMesh::checkFastEquivalWith : Two meshes are not not unstructured !");
+ throw INTERP_KERNEL::Exception("MEDCouplingUMesh::checkFastEquivalWith : Two meshes are not not unstructured !");
}
/*!
* \param [in,out] revNodalIndx - an array, of length \a this->getNumberOfNodes() + 1,
* dividing cell ids in \a revNodal into groups each referring to one
* node. Its every element (except the last one) is an index pointing to the
- * first id of a group of cells. For example cells sharing the node #1 are
- * described by following range of indices:
+ * first id of a group of cells. For example cells sharing the node #1 are
+ * described by following range of indices:
* [ \a revNodalIndx[1], \a revNodalIndx[2] ) and the cell ids are
* \a revNodal[ \a revNodalIndx[1] ], \a revNodal[ \a revNodalIndx[1] + 1], ...
* Number of cells sharing the *i*-th node is
* \a revNodalIndx[ *i*+1 ] - \a revNodalIndx[ *i* ].
* \throw If the coordinates array is not set.
* \throw If the nodal connectivity of cells is not defined.
- *
+ *
* \if ENABLE_EXAMPLES
* \ref cpp_mcumesh_getReverseNodalConnectivity "Here is a C++ example".<br>
* \ref py_mcumesh_getReverseNodalConnectivity "Here is a Python example".
* \endif
*/
-void MEDCouplingUMesh::getReverseNodalConnectivity(DataArrayInt *revNodal, DataArrayInt *revNodalIndx) const
+void MEDCouplingUMesh::getReverseNodalConnectivity(DataArrayIdType *revNodal, DataArrayIdType *revNodalIndx) const
{
checkFullyDefined();
- int nbOfNodes(getNumberOfNodes());
- int *revNodalIndxPtr=(int *)malloc((nbOfNodes+1)*sizeof(int));
- revNodalIndx->useArray(revNodalIndxPtr,true,C_DEALLOC,nbOfNodes+1,1);
+ mcIdType nbOfNodes(getNumberOfNodes());
+ mcIdType *revNodalIndxPtr=(mcIdType *)malloc((nbOfNodes+1)*sizeof(mcIdType));
+ revNodalIndx->useArray(revNodalIndxPtr,true,DeallocType::C_DEALLOC,nbOfNodes+1,1);
std::fill(revNodalIndxPtr,revNodalIndxPtr+nbOfNodes+1,0);
- const int *conn(_nodal_connec->begin()),*connIndex(_nodal_connec_index->begin());
- int nbOfCells(getNumberOfCells()),nbOfEltsInRevNodal(0);
- for(int eltId=0;eltId<nbOfCells;eltId++)
+ const mcIdType *conn(_nodal_connec->begin()),*connIndex(_nodal_connec_index->begin());
+ mcIdType nbOfCells(getNumberOfCells()),nbOfEltsInRevNodal(0);
+ for(mcIdType eltId=0;eltId<nbOfCells;eltId++)
{
- const int *strtNdlConnOfCurCell(conn+connIndex[eltId]+1),*endNdlConnOfCurCell(conn+connIndex[eltId+1]);
- for(const int *iter=strtNdlConnOfCurCell;iter!=endNdlConnOfCurCell;iter++)
+ const mcIdType *strtNdlConnOfCurCell(conn+connIndex[eltId]+1),*endNdlConnOfCurCell(conn+connIndex[eltId+1]);
+ for(const mcIdType *iter=strtNdlConnOfCurCell;iter!=endNdlConnOfCurCell;iter++)
if(*iter>=0)//for polyhedrons
{
nbOfEltsInRevNodal++;
revNodalIndxPtr[(*iter)+1]++;
}
}
- std::transform(revNodalIndxPtr+1,revNodalIndxPtr+nbOfNodes+1,revNodalIndxPtr,revNodalIndxPtr+1,std::plus<int>());
- int *revNodalPtr=(int *)malloc((nbOfEltsInRevNodal)*sizeof(int));
- revNodal->useArray(revNodalPtr,true,C_DEALLOC,nbOfEltsInRevNodal,1);
+ std::transform(revNodalIndxPtr+1,revNodalIndxPtr+nbOfNodes+1,revNodalIndxPtr,revNodalIndxPtr+1,std::plus<mcIdType>());
+ mcIdType *revNodalPtr=(mcIdType *)malloc(nbOfEltsInRevNodal*sizeof(mcIdType));
+ revNodal->useArray(revNodalPtr,true,DeallocType::C_DEALLOC,nbOfEltsInRevNodal,1);
std::fill(revNodalPtr,revNodalPtr+nbOfEltsInRevNodal,-1);
- for(int eltId=0;eltId<nbOfCells;eltId++)
+ for(mcIdType eltId=0;eltId<nbOfCells;eltId++)
{
- const int *strtNdlConnOfCurCell=conn+connIndex[eltId]+1;
- const int *endNdlConnOfCurCell=conn+connIndex[eltId+1];
- for(const int *iter=strtNdlConnOfCurCell;iter!=endNdlConnOfCurCell;iter++)
+ const mcIdType *strtNdlConnOfCurCell=conn+connIndex[eltId]+1;
+ const mcIdType *endNdlConnOfCurCell=conn+connIndex[eltId+1];
+ for(const mcIdType *iter=strtNdlConnOfCurCell;iter!=endNdlConnOfCurCell;iter++)
if(*iter>=0)//for polyhedrons
- *std::find_if(revNodalPtr+revNodalIndxPtr[*iter],revNodalPtr+revNodalIndxPtr[*iter+1],std::bind2nd(std::equal_to<int>(),-1))=eltId;
+ *std::find_if(revNodalPtr+revNodalIndxPtr[*iter],revNodalPtr+revNodalIndxPtr[*iter+1],std::bind2nd(std::equal_to<mcIdType>(),-1))=eltId;
}
}
* returned. The arrays \a desc and \a descIndx (\ref numbering-indirect) describe the descending connectivity,
* i.e. enumerate cells of the result mesh bounding each cell of \a this mesh. The
* arrays \a revDesc and \a revDescIndx (\ref numbering-indirect) describe the reverse descending connectivity,
- * i.e. enumerate cells of \a this mesh bounded by each cell of the result mesh.
+ * i.e. enumerate cells of \a this mesh bounded by each cell of the result mesh.
* \warning For speed reasons, this method does not check if node ids in the nodal
* connectivity correspond to the size of node coordinates array.
* \warning Cells of the result mesh are \b not sorted by geometric type, hence,
* \throw If the nodal connectivity of cells is node defined.
* \throw If \a desc == NULL || \a descIndx == NULL || \a revDesc == NULL || \a
* revDescIndx == NULL.
- *
+ *
* \if ENABLE_EXAMPLES
* \ref cpp_mcumesh_buildDescendingConnectivity "Here is a C++ example".<br>
* \ref py_mcumesh_buildDescendingConnectivity "Here is a Python example".
* \endif
* \sa buildDescendingConnectivity2()
*/
-MEDCouplingUMesh *MEDCouplingUMesh::buildDescendingConnectivity(DataArrayInt *desc, DataArrayInt *descIndx, DataArrayInt *revDesc, DataArrayInt *revDescIndx) const
+MEDCouplingUMesh *MEDCouplingUMesh::buildDescendingConnectivity(DataArrayIdType *desc, DataArrayIdType *descIndx, DataArrayIdType *revDesc, DataArrayIdType *revDescIndx) const
{
return buildDescendingConnectivityGen<MinusOneSonsGenerator>(desc,descIndx,revDesc,revDescIndx,MEDCouplingFastNbrer);
}
* This method returns 4 arrays and a mesh as MEDCouplingUMesh::buildDescendingConnectivity does.
* \sa MEDCouplingUMesh::buildDescendingConnectivity
*/
-MEDCouplingUMesh *MEDCouplingUMesh::explode3DMeshTo1D(DataArrayInt *desc, DataArrayInt *descIndx, DataArrayInt *revDesc, DataArrayInt *revDescIndx) const
+MEDCouplingUMesh *MEDCouplingUMesh::explode3DMeshTo1D(DataArrayIdType *desc, DataArrayIdType *descIndx, DataArrayIdType *revDesc, DataArrayIdType *revDescIndx) const
{
checkFullyDefined();
if(getMeshDimension()!=3)
*
* \sa explode3DMeshTo1D, buildDescendingConnectiviy
*/
-MEDCouplingUMesh *MEDCouplingUMesh::explodeMeshIntoMicroEdges(DataArrayInt *desc, DataArrayInt *descIndx, DataArrayInt *revDesc, DataArrayInt *revDescIndx) const
+MEDCouplingUMesh *MEDCouplingUMesh::explodeMeshIntoMicroEdges(DataArrayIdType *desc, DataArrayIdType *descIndx, DataArrayIdType *revDesc, DataArrayIdType *revDescIndx) const
{
checkFullyDefined();
switch(getMeshDimension())
* cell with id #0 can't be negative, the array \a desc returns ids in FORTRAN mode,
* i.e. cell ids are one-based.
* Arrays \a revDesc and \a revDescIndx (\ref numbering-indirect) describe the reverse descending connectivity,
- * i.e. enumerate cells of \a this mesh bounded by each cell of the result mesh.
+ * i.e. enumerate cells of \a this mesh bounded by each cell of the result mesh.
* \warning For speed reasons, this method does not check if node ids in the nodal
* connectivity correspond to the size of node coordinates array.
* \warning Cells of the result mesh are \b not sorted by geometric type, hence,
* \throw If the nodal connectivity of cells is node defined.
* \throw If \a desc == NULL || \a descIndx == NULL || \a revDesc == NULL || \a
* revDescIndx == NULL.
- *
+ *
* \if ENABLE_EXAMPLES
* \ref cpp_mcumesh_buildDescendingConnectivity2 "Here is a C++ example".<br>
* \ref py_mcumesh_buildDescendingConnectivity2 "Here is a Python example".
* \endif
* \sa buildDescendingConnectivity()
*/
-MEDCouplingUMesh *MEDCouplingUMesh::buildDescendingConnectivity2(DataArrayInt *desc, DataArrayInt *descIndx, DataArrayInt *revDesc, DataArrayInt *revDescIndx) const
+MEDCouplingUMesh *MEDCouplingUMesh::buildDescendingConnectivity2(DataArrayIdType *desc, DataArrayIdType *descIndx, DataArrayIdType *revDesc, DataArrayIdType *revDescIndx) const
{
return buildDescendingConnectivityGen<MinusOneSonsGenerator>(desc,descIndx,revDesc,revDescIndx,MEDCouplingOrientationSensitiveNbrer);
}
* \param [out] neighborsIndx is an array of size this->getNumberOfCells()+1 newly allocated and should be
* dealt by the caller. This arrays allow to use the first output parameter \b neighbors (\ref numbering-indirect).
*/
-void MEDCouplingUMesh::computeNeighborsOfCells(DataArrayInt *&neighbors, DataArrayInt *&neighborsIndx) const
+void MEDCouplingUMesh::computeNeighborsOfCells(DataArrayIdType *&neighbors, DataArrayIdType *&neighborsIndx) const
{
- MCAuto<DataArrayInt> desc=DataArrayInt::New();
- MCAuto<DataArrayInt> descIndx=DataArrayInt::New();
- MCAuto<DataArrayInt> revDesc=DataArrayInt::New();
- MCAuto<DataArrayInt> revDescIndx=DataArrayInt::New();
+ MCAuto<DataArrayIdType> desc=DataArrayIdType::New();
+ MCAuto<DataArrayIdType> descIndx=DataArrayIdType::New();
+ MCAuto<DataArrayIdType> revDesc=DataArrayIdType::New();
+ MCAuto<DataArrayIdType> revDescIndx=DataArrayIdType::New();
MCAuto<MEDCouplingUMesh> meshDM1=buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
meshDM1=0;
ComputeNeighborsOfCellsAdv(desc,descIndx,revDesc,revDescIndx,neighbors,neighborsIndx);
}
-void MEDCouplingUMesh::computeCellNeighborhoodFromNodesOne(const DataArrayInt *nodeNeigh, const DataArrayInt *nodeNeighI, MCAuto<DataArrayInt>& cellNeigh, MCAuto<DataArrayInt>& cellNeighIndex) const
+void MEDCouplingUMesh::computeCellNeighborhoodFromNodesOne(const DataArrayIdType *nodeNeigh, const DataArrayIdType *nodeNeighI, MCAuto<DataArrayIdType>& cellNeigh, MCAuto<DataArrayIdType>& cellNeighIndex) const
{
if(!nodeNeigh || !nodeNeighI)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::computeCellNeighborhoodFromNodesOne : null pointer !");
nodeNeigh->checkNbOfComps(1,"MEDCouplingUMesh::computeCellNeighborhoodFromNodesOne : node neigh");
nodeNeighI->checkNbOfComps(1,"MEDCouplingUMesh::computeCellNeighborhoodFromNodesOne : node neigh index");
nodeNeighI->checkNbOfTuples(1+getNumberOfNodes(),"MEDCouplingUMesh::computeCellNeighborhoodFromNodesOne : invalid length");
- int nbCells(getNumberOfCells());
- const int *c(_nodal_connec->begin()),*ci(_nodal_connec_index->begin()),*ne(nodeNeigh->begin()),*nei(nodeNeighI->begin());
- cellNeigh=DataArrayInt::New(); cellNeigh->alloc(0,1); cellNeighIndex=DataArrayInt::New(); cellNeighIndex->alloc(1,1); cellNeighIndex->setIJ(0,0,0);
- for(int i=0;i<nbCells;i++)
+ mcIdType nbCells=getNumberOfCells();
+ const mcIdType *c(_nodal_connec->begin()),*ci(_nodal_connec_index->begin()),*ne(nodeNeigh->begin()),*nei(nodeNeighI->begin());
+ cellNeigh=DataArrayIdType::New(); cellNeigh->alloc(0,1); cellNeighIndex=DataArrayIdType::New(); cellNeighIndex->alloc(1,1); cellNeighIndex->setIJ(0,0,0);
+ for(mcIdType i=0;i<nbCells;i++)
{
- std::set<int> s;
- for(const int *it=c+ci[i]+1;it!=c+ci[i+1];it++)
+ std::set<mcIdType> s;
+ for(const mcIdType *it=c+ci[i]+1;it!=c+ci[i+1];it++)
if(*it>=0)
s.insert(ne+nei[*it],ne+nei[*it+1]);
s.erase(i);
* parameter allows to select the right part in this array. The number of tuples is equal to the last values in \b neighborsIndx.
* \param [out] neighborsIndx is an array of size this->getNumberOfCells()+1 newly allocated and should be dealt by the caller. This arrays allow to use the first output parameter \b neighbors.
*/
-void MEDCouplingUMesh::ComputeNeighborsOfCellsAdv(const DataArrayInt *desc, const DataArrayInt *descIndx, const DataArrayInt *revDesc, const DataArrayInt *revDescIndx,
- DataArrayInt *&neighbors, DataArrayInt *&neighborsIndx)
+void MEDCouplingUMesh::ComputeNeighborsOfCellsAdv(const DataArrayIdType *desc, const DataArrayIdType *descIndx, const DataArrayIdType *revDesc, const DataArrayIdType *revDescIndx,
+ DataArrayIdType *&neighbors, DataArrayIdType *&neighborsIndx)
{
if(!desc || !descIndx || !revDesc || !revDescIndx)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::ComputeNeighborsOfCellsAdv some input array is empty !");
- const int *descPtr=desc->begin();
- const int *descIPtr=descIndx->begin();
- const int *revDescPtr=revDesc->begin();
- const int *revDescIPtr=revDescIndx->begin();
+ const mcIdType *descPtr=desc->begin();
+ const mcIdType *descIPtr=descIndx->begin();
+ const mcIdType *revDescPtr=revDesc->begin();
+ const mcIdType *revDescIPtr=revDescIndx->begin();
//
- int nbCells=descIndx->getNumberOfTuples()-1;
- MCAuto<DataArrayInt> out0=DataArrayInt::New();
- MCAuto<DataArrayInt> out1=DataArrayInt::New(); out1->alloc(nbCells+1,1);
- int *out1Ptr=out1->getPointer();
+ mcIdType nbCells=descIndx->getNumberOfTuples()-1;
+ MCAuto<DataArrayIdType> out0=DataArrayIdType::New();
+ MCAuto<DataArrayIdType> out1=DataArrayIdType::New(); out1->alloc(nbCells+1,1);
+ mcIdType *out1Ptr=out1->getPointer();
*out1Ptr++=0;
out0->reserve(desc->getNumberOfTuples());
- for(int i=0;i<nbCells;i++,descIPtr++,out1Ptr++)
+ for(mcIdType i=0;i<nbCells;i++,descIPtr++,out1Ptr++)
{
- for(const int *w1=descPtr+descIPtr[0];w1!=descPtr+descIPtr[1];w1++)
+ for(const mcIdType *w1=descPtr+descIPtr[0];w1!=descPtr+descIPtr[1];w1++)
{
- std::set<int> s(revDescPtr+revDescIPtr[*w1],revDescPtr+revDescIPtr[(*w1)+1]);
+ std::set<mcIdType> s(revDescPtr+revDescIPtr[*w1],revDescPtr+revDescIPtr[(*w1)+1]);
s.erase(i);
out0->insertAtTheEnd(s.begin(),s.end());
}
/*!
* Explodes \a this into edges whatever its dimension.
*/
-MCAuto<MEDCouplingUMesh> MEDCouplingUMesh::explodeIntoEdges(MCAuto<DataArrayInt>& desc, MCAuto<DataArrayInt>& descIndex, MCAuto<DataArrayInt>& revDesc, MCAuto<DataArrayInt>& revDescIndx) const
+MCAuto<MEDCouplingUMesh> MEDCouplingUMesh::explodeIntoEdges(MCAuto<DataArrayIdType>& desc, MCAuto<DataArrayIdType>& descIndex, MCAuto<DataArrayIdType>& revDesc, MCAuto<DataArrayIdType>& revDescIndx) const
{
checkFullyDefined();
int mdim(getMeshDimension());
- desc=DataArrayInt::New(); descIndex=DataArrayInt::New(); revDesc=DataArrayInt::New(); revDescIndx=DataArrayInt::New();
+ desc=DataArrayIdType::New(); descIndex=DataArrayIdType::New(); revDesc=DataArrayIdType::New(); revDescIndx=DataArrayIdType::New();
MCAuto<MEDCouplingUMesh> mesh1D;
switch(mdim)
{
* The number of tuples is equal to the last values in \b neighborsIndx.
* \param [out] neighborsIdx is an array of size this->getNumberOfCells()+1 newly allocated and should
* be dealt by the caller. This arrays allow to use the first output parameter \b neighbors.
- *
+ *
* \sa MEDCouplingUMesh::computeEnlargedNeighborsOfNodes
*/
-void MEDCouplingUMesh::computeNeighborsOfNodes(DataArrayInt *&neighbors, DataArrayInt *&neighborsIdx) const
+void MEDCouplingUMesh::computeNeighborsOfNodes(DataArrayIdType *&neighbors, DataArrayIdType *&neighborsIdx) const
{
checkFullyDefined();
- int mdim(getMeshDimension()),nbNodes(getNumberOfNodes());
- MCAuto<DataArrayInt> desc(DataArrayInt::New()),descIndx(DataArrayInt::New()),revDesc(DataArrayInt::New()),revDescIndx(DataArrayInt::New());
+ mcIdType mdim(getMeshDimension()),nbNodes(getNumberOfNodes());
+ MCAuto<DataArrayIdType> desc(DataArrayIdType::New()),descIndx(DataArrayIdType::New()),revDesc(DataArrayIdType::New()),revDescIndx(DataArrayIdType::New());
MCConstAuto<MEDCouplingUMesh> mesh1D;
switch(mdim)
{
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::computeNeighborsOfNodes : Mesh dimension supported are [3,2,1] !");
}
}
- desc=DataArrayInt::New(); descIndx=DataArrayInt::New(); revDesc=0; revDescIndx=0;
+ desc=DataArrayIdType::New(); descIndx=DataArrayIdType::New(); revDesc=0; revDescIndx=0;
mesh1D->getReverseNodalConnectivity(desc,descIndx);
- MCAuto<DataArrayInt> ret0(DataArrayInt::New());
+ MCAuto<DataArrayIdType> ret0(DataArrayIdType::New());
ret0->alloc(desc->getNumberOfTuples(),1);
- int *r0Pt(ret0->getPointer());
- const int *c1DPtr(mesh1D->getNodalConnectivity()->begin()),*rn(desc->begin()),*rni(descIndx->begin());
- for(int i=0;i<nbNodes;i++,rni++)
+ mcIdType *r0Pt(ret0->getPointer());
+ const mcIdType *c1DPtr(mesh1D->getNodalConnectivity()->begin()),*rn(desc->begin()),*rni(descIndx->begin());
+ for(mcIdType i=0;i<nbNodes;i++,rni++)
{
- for(const int *oneDCellIt=rn+rni[0];oneDCellIt!=rn+rni[1];oneDCellIt++)
+ for(const mcIdType *oneDCellIt=rn+rni[0];oneDCellIt!=rn+rni[1];oneDCellIt++)
*r0Pt++=c1DPtr[3*(*oneDCellIt)+1]==i?c1DPtr[3*(*oneDCellIt)+2]:c1DPtr[3*(*oneDCellIt)+1];
}
neighbors=ret0.retn();
* Computes enlarged neighbors for each nodes in \a this. The behavior of this method is close to MEDCouplingUMesh::computeNeighborsOfNodes except that the neighborhood of each node is wider here.
* A node j is considered to be in the neighborhood of i if and only if there is a cell in \a this containing in its nodal connectivity both i and j.
* This method is useful to find ghost cells of a part of a mesh with a code based on fields on nodes.
- *
+ *
* \sa MEDCouplingUMesh::computeNeighborsOfNodes
*/
-void MEDCouplingUMesh::computeEnlargedNeighborsOfNodes(MCAuto<DataArrayInt> &neighbors, MCAuto<DataArrayInt>& neighborsIdx) const
+void MEDCouplingUMesh::computeEnlargedNeighborsOfNodes(MCAuto<DataArrayIdType> &neighbors, MCAuto<DataArrayIdType>& neighborsIdx) const
{
checkFullyDefined();
- int nbOfNodes(getNumberOfNodes());
- const int *conn(_nodal_connec->begin()),*connIndex(_nodal_connec_index->begin());
- int nbOfCells(getNumberOfCells());
- std::vector< std::set<int> > st0(nbOfNodes);
- for(int eltId=0;eltId<nbOfCells;eltId++)
- {
- const int *strtNdlConnOfCurCell(conn+connIndex[eltId]+1),*endNdlConnOfCurCell(conn+connIndex[eltId+1]);
- std::set<int> s(strtNdlConnOfCurCell,endNdlConnOfCurCell); s.erase(-1); //for polyhedrons
- for(std::set<int>::const_iterator iter2=s.begin();iter2!=s.end();iter2++)
+ mcIdType nbOfNodes(getNumberOfNodes());
+ const mcIdType *conn(_nodal_connec->begin()),*connIndex(_nodal_connec_index->begin());
+ mcIdType nbOfCells=getNumberOfCells();
+ std::vector< std::set<mcIdType> > st0(nbOfNodes);
+ for(mcIdType eltId=0;eltId<nbOfCells;eltId++)
+ {
+ const mcIdType *strtNdlConnOfCurCell(conn+connIndex[eltId]+1),*endNdlConnOfCurCell(conn+connIndex[eltId+1]);
+ std::set<mcIdType> s(strtNdlConnOfCurCell,endNdlConnOfCurCell); s.erase(-1); //for polyhedrons
+ for(std::set<mcIdType>::const_iterator iter2=s.begin();iter2!=s.end();iter2++)
st0[*iter2].insert(s.begin(),s.end());
}
- neighborsIdx=DataArrayInt::New(); neighborsIdx->alloc(nbOfNodes+1,1); neighborsIdx->setIJ(0,0,0);
+ neighborsIdx=DataArrayIdType::New(); neighborsIdx->alloc(nbOfNodes+1,1); neighborsIdx->setIJ(0,0,0);
{
- int *neighIdx(neighborsIdx->getPointer());
- for(std::vector< std::set<int> >::const_iterator it=st0.begin();it!=st0.end();it++,neighIdx++)
+ mcIdType *neighIdx(neighborsIdx->getPointer());
+ for(std::vector< std::set<mcIdType> >::const_iterator it=st0.begin();it!=st0.end();it++,neighIdx++)
{
if ((*it).empty())
neighIdx[1]=neighIdx[0];
else
- neighIdx[1]=neighIdx[0]+(*it).size()-1;
+ neighIdx[1]=neighIdx[0]+ToIdType((*it).size())-1;
}
}
- neighbors=DataArrayInt::New(); neighbors->alloc(neighborsIdx->back(),1);
+ neighbors=DataArrayIdType::New(); neighbors->alloc(neighborsIdx->back(),1);
{
- const int *neighIdx(neighborsIdx->begin());
- int *neigh(neighbors->getPointer()),nodeId(0);
- for(std::vector< std::set<int> >::const_iterator it=st0.begin();it!=st0.end();it++,neighIdx++,nodeId++)
+ const mcIdType *neighIdx(neighborsIdx->begin());
+ mcIdType *neigh(neighbors->getPointer()),nodeId(0);
+ for(std::vector< std::set<mcIdType> >::const_iterator it=st0.begin();it!=st0.end();it++,neighIdx++,nodeId++)
{
- std::set<int> s(*it); s.erase(nodeId);
+ std::set<mcIdType> s(*it); s.erase(nodeId);
std::copy(s.begin(),s.end(),neigh+*neighIdx);
}
}
* \ref py_mcumesh_convertToPolyTypes "Here is a Python example".
* \endif
*/
-void MEDCouplingUMesh::convertToPolyTypes(const int *cellIdsToConvertBg, const int *cellIdsToConvertEnd)
+void MEDCouplingUMesh::convertToPolyTypes(const mcIdType *cellIdsToConvertBg, const mcIdType *cellIdsToConvertEnd)
{
checkFullyDefined();
int dim=getMeshDimension();
if(dim<2 || dim>3)
throw INTERP_KERNEL::Exception("Invalid mesh dimension : must be 2 or 3 !");
- int nbOfCells(getNumberOfCells());
+ mcIdType nbOfCells=getNumberOfCells();
if(dim==2)
{
- const int *connIndex=_nodal_connec_index->begin();
- int *conn=_nodal_connec->getPointer();
- for(const int *iter=cellIdsToConvertBg;iter!=cellIdsToConvertEnd;iter++)
+ const mcIdType *connIndex=_nodal_connec_index->begin();
+ mcIdType *conn=_nodal_connec->getPointer();
+ for(const mcIdType *iter=cellIdsToConvertBg;iter!=cellIdsToConvertEnd;iter++)
{
if(*iter>=0 && *iter<nbOfCells)
{
}
else
{
- int *connIndex(_nodal_connec_index->getPointer());
- const int *connOld(_nodal_connec->getConstPointer());
- MCAuto<DataArrayInt> connNew(DataArrayInt::New()),connNewI(DataArrayInt::New()); connNew->alloc(0,1); connNewI->alloc(1,1); connNewI->setIJ(0,0,0);
+ mcIdType *connIndex(_nodal_connec_index->getPointer());
+ const mcIdType *connOld(_nodal_connec->getConstPointer());
+ MCAuto<DataArrayIdType> connNew(DataArrayIdType::New()),connNewI(DataArrayIdType::New()); connNew->alloc(0,1); connNewI->alloc(1,1); connNewI->setIJ(0,0,0);
std::vector<bool> toBeDone(nbOfCells,false);
- for(const int *iter=cellIdsToConvertBg;iter!=cellIdsToConvertEnd;iter++)
+ for(const mcIdType *iter=cellIdsToConvertBg;iter!=cellIdsToConvertEnd;iter++)
{
if(*iter>=0 && *iter<nbOfCells)
toBeDone[*iter]=true;
throw INTERP_KERNEL::Exception(oss.str());
}
}
- for(int cellId=0;cellId<nbOfCells;cellId++)
+ for(mcIdType cellId=0;cellId<nbOfCells;cellId++)
{
- int pos(connIndex[cellId]),posP1(connIndex[cellId+1]);
- int lgthOld(posP1-pos-1);
+ mcIdType pos(connIndex[cellId]),posP1(connIndex[cellId+1]);
+ mcIdType lgthOld(posP1-pos-1);
if(toBeDone[cellId])
{
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel((INTERP_KERNEL::NormalizedCellType)connOld[pos]);
unsigned nbOfFaces(cm.getNumberOfSons2(connOld+pos+1,lgthOld));
- int *tmp(new int[nbOfFaces*lgthOld+1]);
- int *work=tmp; *work++=INTERP_KERNEL::NORM_POLYHED;
+ mcIdType *tmp(new mcIdType[nbOfFaces*lgthOld+1]);
+ mcIdType *work=tmp; *work++=INTERP_KERNEL::NORM_POLYHED;
for(unsigned j=0;j<nbOfFaces;j++)
{
INTERP_KERNEL::NormalizedCellType type;
}
std::size_t newLgth(std::distance(tmp,work)-1);//-1 for last -1
connNew->pushBackValsSilent(tmp,tmp+newLgth);
- connNewI->pushBackSilent(connNewI->back()+(int)newLgth);
+ connNewI->pushBackSilent(connNewI->back()+ToIdType(newLgth));
delete [] tmp;
}
else
*/
void MEDCouplingUMesh::convertAllToPoly()
{
- int nbOfCells=getNumberOfCells();
- std::vector<int> cellIds(nbOfCells);
- for(int i=0;i<nbOfCells;i++)
+ mcIdType nbOfCells=getNumberOfCells();
+ std::vector<mcIdType> cellIds(nbOfCells);
+ for(mcIdType i=0;i<nbOfCells;i++)
cellIds[i]=i;
- convertToPolyTypes(&cellIds[0],&cellIds[0]+cellIds.size());
+ convertToPolyTypes(&cellIds[0],&cellIds[0]+ToIdType(cellIds.size()));
}
/*!
checkFullyDefined();
if(getMeshDimension()!=3 || getSpaceDimension()!=3)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::convertExtrudedPolyhedra works on umeshes with meshdim equal to 3 and spaceDim equal to 3 too!");
- int nbOfCells=getNumberOfCells();
- MCAuto<DataArrayInt> newCi=DataArrayInt::New();
+ mcIdType nbOfCells=getNumberOfCells();
+ MCAuto<DataArrayIdType> newCi=DataArrayIdType::New();
newCi->alloc(nbOfCells+1,1);
- int *newci=newCi->getPointer();
- const int *ci=_nodal_connec_index->getConstPointer();
- const int *c=_nodal_connec->getConstPointer();
+ mcIdType *newci=newCi->getPointer();
+ const mcIdType *ci=_nodal_connec_index->getConstPointer();
+ const mcIdType *c=_nodal_connec->getConstPointer();
newci[0]=0;
- for(int i=0;i<nbOfCells;i++)
+ for(mcIdType i=0;i<nbOfCells;i++)
{
INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)c[ci[i]];
if(type==INTERP_KERNEL::NORM_POLYHED)
std::ostringstream oss; oss << "MEDCouplingUMesh::convertExtrudedPolyhedra : cell # " << i << " is a polhedron with 1 face but there is a mismatch of number of nodes in face should be even !";
throw INTERP_KERNEL::Exception(oss.str());
}
- int n1=(int)(n2/2);
+ mcIdType n1=ToIdType(n2/2);
newci[i+1]=7*n1+2+newci[i];//6*n1 (nodal length) + n1+2 (number of faces) - 1 (number of '-1' separator is equal to number of faces -1) + 1 (for cell type)
}
else
newci[i+1]=(ci[i+1]-ci[i])+newci[i];
}
- MCAuto<DataArrayInt> newC=DataArrayInt::New();
+ MCAuto<DataArrayIdType> newC=DataArrayIdType::New();
newC->alloc(newci[nbOfCells],1);
- int *newc=newC->getPointer();
- for(int i=0;i<nbOfCells;i++)
+ mcIdType *newc=newC->getPointer();
+ for(mcIdType i=0;i<nbOfCells;i++)
{
INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)c[ci[i]];
if(type==INTERP_KERNEL::NORM_POLYHED)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::unPolyze works on umeshes with meshdim equals to 0, 1 2 or 3 !");
if(mdim<=1)
return false;
- int nbOfCells=getNumberOfCells();
+ mcIdType nbOfCells=getNumberOfCells();
if(nbOfCells<1)
return false;
- int initMeshLgth=getNodalConnectivityArrayLen();
- int *conn=_nodal_connec->getPointer();
- int *index=_nodal_connec_index->getPointer();
- int posOfCurCell=0;
- int newPos=0;
- int lgthOfCurCell;
+ mcIdType initMeshLgth=getNodalConnectivityArrayLen();
+ mcIdType *conn=_nodal_connec->getPointer();
+ mcIdType *index=_nodal_connec_index->getPointer();
+ mcIdType posOfCurCell=0;
+ mcIdType newPos=0;
+ mcIdType lgthOfCurCell;
bool ret=false;
- for(int i=0;i<nbOfCells;i++)
+ for(mcIdType i=0;i<nbOfCells;i++)
{
lgthOfCurCell=index[i+1]-posOfCurCell;
INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)conn[posOfCurCell];
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(type);
INTERP_KERNEL::NormalizedCellType newType=INTERP_KERNEL::NORM_ERROR;
- int newLgth;
+ mcIdType newLgth;
if(cm.isDynamic())
{
switch(cm.getDimension())
{
case 2:
{
- INTERP_KERNEL::AutoPtr<int> tmp=new int[lgthOfCurCell-1];
- std::copy(conn+posOfCurCell+1,conn+posOfCurCell+lgthOfCurCell,(int *)tmp);
+ INTERP_KERNEL::AutoPtr<mcIdType> tmp=new mcIdType[lgthOfCurCell-1];
+ std::copy(conn+posOfCurCell+1,conn+posOfCurCell+lgthOfCurCell,(mcIdType *)tmp);
newType=INTERP_KERNEL::CellSimplify::tryToUnPoly2D(cm.isQuadratic(),tmp,lgthOfCurCell-1,conn+newPos+1,newLgth);
break;
}
case 3:
{
- int nbOfFaces,lgthOfPolyhConn;
- INTERP_KERNEL::AutoPtr<int> zipFullReprOfPolyh=INTERP_KERNEL::CellSimplify::getFullPolyh3DCell(type,conn+posOfCurCell+1,lgthOfCurCell-1,nbOfFaces,lgthOfPolyhConn);
+ mcIdType nbOfFaces,lgthOfPolyhConn;
+ INTERP_KERNEL::AutoPtr<mcIdType> zipFullReprOfPolyh=INTERP_KERNEL::CellSimplify::getFullPolyh3DCell(type,conn+posOfCurCell+1,lgthOfCurCell-1,nbOfFaces,lgthOfPolyhConn);
newType=INTERP_KERNEL::CellSimplify::tryToUnPoly3D(zipFullReprOfPolyh,nbOfFaces,lgthOfPolyhConn,conn+newPos+1,newLgth);
break;
}
/*!
* This method expects that spaceDimension is equal to 3 and meshDimension equal to 3.
* This method performs operation only on polyhedrons in \b this. If no polyhedrons exists in \b this, \b this remains unchanged.
- * This method allows to merge if any coplanar 3DSurf cells that may appear in some polyhedrons cells.
+ * This method allows to merge if any coplanar 3DSurf cells that may appear in some polyhedrons cells.
*
- * \param [in] eps is a relative precision that allows to establish if some 3D plane are coplanar or not. This epsilon is used to recenter around origin to have maximal
+ * \param [in] eps is a relative precision that allows to establish if some 3D plane are coplanar or not. This epsilon is used to recenter around origin to have maximal
* precision.
*/
void MEDCouplingUMesh::simplifyPolyhedra(double eps)
MCAuto<DataArrayDouble> coords=getCoords()->deepCopy();
coords->recenterForMaxPrecision(eps);
//
- int nbOfCells=getNumberOfCells();
- const int *conn=_nodal_connec->getConstPointer();
- const int *index=_nodal_connec_index->getConstPointer();
- MCAuto<DataArrayInt> connINew=DataArrayInt::New();
+ mcIdType nbOfCells=getNumberOfCells();
+ const mcIdType *conn=_nodal_connec->getConstPointer();
+ const mcIdType *index=_nodal_connec_index->getConstPointer();
+ MCAuto<DataArrayIdType> connINew=DataArrayIdType::New();
connINew->alloc(nbOfCells+1,1);
- int *connINewPtr=connINew->getPointer(); *connINewPtr++=0;
- MCAuto<DataArrayInt> connNew=DataArrayInt::New(); connNew->alloc(0,1);
- MCAuto<DataArrayInt> E_Fi(DataArrayInt::New()), E_F(DataArrayInt::New()), F_Ei(DataArrayInt::New()), F_E(DataArrayInt::New());
+ mcIdType *connINewPtr=connINew->getPointer(); *connINewPtr++=0;
+ MCAuto<DataArrayIdType> connNew=DataArrayIdType::New(); connNew->alloc(0,1);
+ MCAuto<DataArrayIdType> E_Fi(DataArrayIdType::New()), E_F(DataArrayIdType::New()), F_Ei(DataArrayIdType::New()), F_E(DataArrayIdType::New());
MCAuto<MEDCouplingUMesh> m_faces(buildDescendingConnectivity(E_F, E_Fi, F_E, F_Ei));
bool changed=false;
- for(int i=0;i<nbOfCells;i++,connINewPtr++)
+ for(mcIdType i=0;i<nbOfCells;i++,connINewPtr++)
{
- if(conn[index[i]]==(int)INTERP_KERNEL::NORM_POLYHED)
+ if(conn[index[i]]==ToIdType(INTERP_KERNEL::NORM_POLYHED))
{
SimplifyPolyhedronCell(eps,coords, i,connNew, m_faces, E_Fi, E_F, F_Ei, F_E);
changed=true;
/*!
* This method returns all node ids used in the connectivity of \b this. The data array returned has to be dealt by the caller.
* The returned node ids are sorted ascendingly. This method is close to MEDCouplingUMesh::getNodeIdsInUse except
- * the format of the returned DataArrayInt instance.
- *
- * \return a newly allocated DataArrayInt sorted ascendingly of fetched node ids.
+ * the format of the returned DataArrayIdType instance.
+ *
+ * \return a newly allocated DataArrayIdType sorted ascendingly of fetched node ids.
* \sa MEDCouplingUMesh::getNodeIdsInUse, areAllNodesFetched
*/
-DataArrayInt *MEDCouplingUMesh::computeFetchedNodeIds() const
+DataArrayIdType *MEDCouplingUMesh::computeFetchedNodeIds() const
{
checkConnectivityFullyDefined();
- const int *maxEltPt(std::max_element(_nodal_connec->begin(),_nodal_connec->end()));
- int maxElt(maxEltPt==_nodal_connec->end()?0:std::abs(*maxEltPt)+1);
+ const mcIdType *maxEltPt(std::max_element(_nodal_connec->begin(),_nodal_connec->end()));
+ mcIdType maxElt(maxEltPt==_nodal_connec->end()?0:std::abs(*maxEltPt)+1);
std::vector<bool> retS(maxElt,false);
computeNodeIdsAlg(retS);
- return DataArrayInt::BuildListOfSwitchedOn(retS);
+ return DataArrayIdType::BuildListOfSwitchedOn(retS);
}
/*!
*/
void MEDCouplingUMesh::computeNodeIdsAlg(std::vector<bool>& nodeIdsInUse) const
{
- int nbOfNodes((int)nodeIdsInUse.size()),nbOfCells(getNumberOfCells());
- const int *connIndex(_nodal_connec_index->getConstPointer()),*conn(_nodal_connec->getConstPointer());
- for(int i=0;i<nbOfCells;i++)
- for(int j=connIndex[i]+1;j<connIndex[i+1];j++)
+ mcIdType nbOfNodes=ToIdType(nodeIdsInUse.size()),
+ nbOfCells=getNumberOfCells();
+ const mcIdType *connIndex(_nodal_connec_index->getConstPointer()),*conn(_nodal_connec->getConstPointer());
+ for(mcIdType i=0;i<nbOfCells;i++)
+ for(mcIdType j=connIndex[i]+1;j<connIndex[i+1];j++)
if(conn[j]>=0)
{
if(conn[j]<nbOfNodes)
struct MEDCouplingAccVisit
{
MEDCouplingAccVisit():_new_nb_of_nodes(0) { }
- int operator()(int val) { if(val!=-1) return _new_nb_of_nodes++; else return -1; }
- int _new_nb_of_nodes;
+ mcIdType operator()(mcIdType val) { if(val!=-1) return _new_nb_of_nodes++; else return -1; }
+ mcIdType _new_nb_of_nodes;
};
/// @endcond
/*!
* Finds nodes not used in any cell and returns an array giving a new id to every node
* by excluding the unused nodes, for which the array holds -1. The result array is
- * a mapping in "Old to New" mode.
+ * a mapping in "Old to New" mode.
* \param [out] nbrOfNodesInUse - number of node ids present in the nodal connectivity.
- * \return DataArrayInt * - a new instance of DataArrayInt. Its length is \a
+ * \return DataArrayIdType * - a new instance of DataArrayIdType. Its length is \a
* this->getNumberOfNodes(). It holds for each node of \a this mesh either -1
* if the node is unused or a new id else. The caller is to delete this
- * array using decrRef() as it is no more needed.
+ * array using decrRef() as it is no more needed.
* \throw If the coordinates array is not set.
* \throw If the nodal connectivity of cells is not defined.
* \throw If the nodal connectivity includes an invalid id.
* \endif
* \sa computeFetchedNodeIds, computeNodeIdsAlg()
*/
-DataArrayInt *MEDCouplingUMesh::getNodeIdsInUse(int& nbrOfNodesInUse) const
+DataArrayIdType *MEDCouplingUMesh::getNodeIdsInUse(mcIdType& nbrOfNodesInUse) const
{
nbrOfNodesInUse=-1;
- int nbOfNodes(getNumberOfNodes());
- MCAuto<DataArrayInt> ret=DataArrayInt::New();
+ mcIdType nbOfNodes(getNumberOfNodes());
+ MCAuto<DataArrayIdType> ret=DataArrayIdType::New();
ret->alloc(nbOfNodes,1);
- int *traducer=ret->getPointer();
+ mcIdType *traducer=ret->getPointer();
std::fill(traducer,traducer+nbOfNodes,-1);
- int nbOfCells=getNumberOfCells();
- const int *connIndex=_nodal_connec_index->getConstPointer();
- const int *conn=_nodal_connec->getConstPointer();
- for(int i=0;i<nbOfCells;i++)
- for(int j=connIndex[i]+1;j<connIndex[i+1];j++)
+ mcIdType nbOfCells=getNumberOfCells();
+ const mcIdType *connIndex=_nodal_connec_index->getConstPointer();
+ const mcIdType *conn=_nodal_connec->getConstPointer();
+ for(mcIdType i=0;i<nbOfCells;i++)
+ for(mcIdType j=connIndex[i]+1;j<connIndex[i+1];j++)
if(conn[j]>=0)
{
if(conn[j]<nbOfNodes)
throw INTERP_KERNEL::Exception(oss.str());
}
}
- nbrOfNodesInUse=(int)std::count(traducer,traducer+nbOfNodes,1);
+ nbrOfNodesInUse=ToIdType(std::count(traducer,traducer+nbOfNodes,1));
std::transform(traducer,traducer+nbOfNodes,traducer,MEDCouplingAccVisit());
return ret.retn();
}
* For each cell in \b this the number of nodes constituting cell is computed.
* For each polyhedron cell, the sum of the number of nodes of each face constituting polyhedron cell is returned.
* So for pohyhedrons some nodes can be counted several times in the returned result.
- *
+ *
* \return a newly allocated array
* \sa MEDCouplingUMesh::computeEffectiveNbOfNodesPerCell
*/
-DataArrayInt *MEDCouplingUMesh::computeNbOfNodesPerCell() const
+DataArrayIdType *MEDCouplingUMesh::computeNbOfNodesPerCell() const
{
checkConnectivityFullyDefined();
- int nbOfCells=getNumberOfCells();
- MCAuto<DataArrayInt> ret=DataArrayInt::New();
+ mcIdType nbOfCells=getNumberOfCells();
+ MCAuto<DataArrayIdType> ret=DataArrayIdType::New();
ret->alloc(nbOfCells,1);
- int *retPtr=ret->getPointer();
- const int *conn=getNodalConnectivity()->getConstPointer();
- const int *connI=getNodalConnectivityIndex()->getConstPointer();
- for(int i=0;i<nbOfCells;i++,retPtr++)
+ mcIdType *retPtr=ret->getPointer();
+ const mcIdType *conn=getNodalConnectivity()->getConstPointer();
+ const mcIdType *connI=getNodalConnectivityIndex()->getConstPointer();
+ for(mcIdType i=0;i<nbOfCells;i++,retPtr++)
{
- if(conn[connI[i]]!=(int)INTERP_KERNEL::NORM_POLYHED)
+ if(conn[connI[i]]!=ToIdType(INTERP_KERNEL::NORM_POLYHED))
*retPtr=connI[i+1]-connI[i]-1;
else
- *retPtr=connI[i+1]-connI[i]-1-std::count(conn+connI[i]+1,conn+connI[i+1],-1);
+ *retPtr=connI[i+1]-connI[i]-1-ToIdType(std::count(conn+connI[i]+1,conn+connI[i+1],-1));
}
return ret.retn();
}
* This method computes effective number of nodes per cell. That is to say nodes appearing several times in nodal connectivity of a cell,
* will be counted only once here whereas it will be counted several times in MEDCouplingUMesh::computeNbOfNodesPerCell method.
*
- * \return DataArrayInt * - new object to be deallocated by the caller.
+ * \return DataArrayIdType * - new object to be deallocated by the caller.
* \sa MEDCouplingUMesh::computeNbOfNodesPerCell
*/
-DataArrayInt *MEDCouplingUMesh::computeEffectiveNbOfNodesPerCell() const
+DataArrayIdType *MEDCouplingUMesh::computeEffectiveNbOfNodesPerCell() const
{
checkConnectivityFullyDefined();
- int nbOfCells=getNumberOfCells();
- MCAuto<DataArrayInt> ret=DataArrayInt::New();
+ mcIdType nbOfCells=getNumberOfCells();
+ MCAuto<DataArrayIdType> ret=DataArrayIdType::New();
ret->alloc(nbOfCells,1);
- int *retPtr=ret->getPointer();
- const int *conn=getNodalConnectivity()->getConstPointer();
- const int *connI=getNodalConnectivityIndex()->getConstPointer();
- for(int i=0;i<nbOfCells;i++,retPtr++)
- {
- std::set<int> s(conn+connI[i]+1,conn+connI[i+1]);
- if(conn[connI[i]]!=(int)INTERP_KERNEL::NORM_POLYHED)
- *retPtr=(int)s.size();
+ mcIdType *retPtr=ret->getPointer();
+ const mcIdType *conn=getNodalConnectivity()->getConstPointer();
+ const mcIdType *connI=getNodalConnectivityIndex()->getConstPointer();
+ for(mcIdType i=0;i<nbOfCells;i++,retPtr++)
+ {
+ std::set<mcIdType> s(conn+connI[i]+1,conn+connI[i+1]);
+ if(conn[connI[i]]!=ToIdType(INTERP_KERNEL::NORM_POLYHED))
+ *retPtr=ToIdType(s.size());
else
{
s.erase(-1);
- *retPtr=(int)s.size();
+ *retPtr=ToIdType(s.size());
}
}
return ret.retn();
/*!
* This method returns a newly allocated array containing this->getNumberOfCells() tuples and 1 component.
* For each cell in \b this the number of faces constituting (entity of dimension this->getMeshDimension()-1) cell is computed.
- *
+ *
* \return a newly allocated array
*/
-DataArrayInt *MEDCouplingUMesh::computeNbOfFacesPerCell() const
+DataArrayIdType *MEDCouplingUMesh::computeNbOfFacesPerCell() const
{
checkConnectivityFullyDefined();
- int nbOfCells=getNumberOfCells();
- MCAuto<DataArrayInt> ret=DataArrayInt::New();
+ mcIdType nbOfCells=getNumberOfCells();
+ MCAuto<DataArrayIdType> ret=DataArrayIdType::New();
ret->alloc(nbOfCells,1);
- int *retPtr=ret->getPointer();
- const int *conn=getNodalConnectivity()->getConstPointer();
- const int *connI=getNodalConnectivityIndex()->getConstPointer();
- for(int i=0;i<nbOfCells;i++,retPtr++,connI++)
+ mcIdType *retPtr=ret->getPointer();
+ const mcIdType *conn=getNodalConnectivity()->getConstPointer();
+ const mcIdType *connI=getNodalConnectivityIndex()->getConstPointer();
+ for(mcIdType i=0;i<nbOfCells;i++,retPtr++,connI++)
{
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel((INTERP_KERNEL::NormalizedCellType)conn[*connI]);
*retPtr=cm.getNumberOfSons2(conn+connI[0]+1,connI[1]-connI[0]-1);
/*!
* Removes unused nodes (the node coordinates array is shorten) and returns an array
* mapping between new and old node ids in "Old to New" mode. -1 values in the returned
- * array mean that the corresponding old node is no more used.
- * \return DataArrayInt * - a new instance of DataArrayInt of length \a
+ * array mean that the corresponding old node is no more used.
+ * \return DataArrayIdType * - a new instance of DataArrayIdType of length \a
* this->getNumberOfNodes() before call of this method. The caller is to
- * delete this array using decrRef() as it is no more needed.
+ * delete this array using decrRef() as it is no more needed.
* \throw If the coordinates array is not set.
* \throw If the nodal connectivity of cells is not defined.
* \throw If the nodal connectivity includes an invalid id.
* \ref py_mcumesh_zipCoordsTraducer "Here is a Python example".
* \endif
*/
-DataArrayInt *MEDCouplingUMesh::zipCoordsTraducer()
+DataArrayIdType *MEDCouplingUMesh::zipCoordsTraducer()
{
return MEDCouplingPointSet::zipCoordsTraducer();
}
* This method stands if 'cell1' and 'cell2' are equals regarding 'compType' policy.
* The semantic of 'compType' is specified in MEDCouplingPointSet::zipConnectivityTraducer method.
*/
-int MEDCouplingUMesh::AreCellsEqual(const int *conn, const int *connI, int cell1, int cell2, int compType)
+int MEDCouplingUMesh::AreCellsEqual(const mcIdType *conn, const mcIdType *connI, mcIdType cell1, mcIdType cell2, int compType)
{
switch(compType)
{
/*!
* This method is the last step of the MEDCouplingPointSet::zipConnectivityTraducer with policy 0.
*/
-int MEDCouplingUMesh::AreCellsEqualPolicy0(const int *conn, const int *connI, int cell1, int cell2)
+int MEDCouplingUMesh::AreCellsEqualPolicy0(const mcIdType *conn, const mcIdType *connI, mcIdType cell1, mcIdType cell2)
{
if(connI[cell1+1]-connI[cell1]==connI[cell2+1]-connI[cell2])
return std::equal(conn+connI[cell1]+1,conn+connI[cell1+1],conn+connI[cell2]+1)?1:0;
/*!
* This method is the last step of the MEDCouplingPointSet::zipConnectivityTraducer with policy 1.
*/
-int MEDCouplingUMesh::AreCellsEqualPolicy1(const int *conn, const int *connI, int cell1, int cell2)
+int MEDCouplingUMesh::AreCellsEqualPolicy1(const mcIdType *conn, const mcIdType *connI, mcIdType cell1, mcIdType cell2)
{
- int sz=connI[cell1+1]-connI[cell1];
+ mcIdType sz=connI[cell1+1]-connI[cell1];
if(sz==connI[cell2+1]-connI[cell2])
{
if(conn[connI[cell1]]==conn[connI[cell2]])
{
if(dim!=1)
{
- int sz1=2*(sz-1);
- INTERP_KERNEL::AutoPtr<int> tmp=new int[sz1];
- int *work=std::copy(conn+connI[cell1]+1,conn+connI[cell1+1],(int *)tmp);
+ mcIdType sz1=2*(sz-1);
+ INTERP_KERNEL::AutoPtr<mcIdType> tmp=new mcIdType[sz1];
+ mcIdType *work=std::copy(conn+connI[cell1]+1,conn+connI[cell1+1],(mcIdType *)tmp);
std::copy(conn+connI[cell1]+1,conn+connI[cell1+1],work);
- work=std::search((int *)tmp,(int *)tmp+sz1,conn+connI[cell2]+1,conn+connI[cell2+1]);
+ work=std::search((mcIdType *)tmp,(mcIdType *)tmp+sz1,conn+connI[cell2]+1,conn+connI[cell2+1]);
return work!=tmp+sz1?1:0;
}
else
/*!
* This method is the last step of the MEDCouplingPointSet::zipConnectivityTraducer with policy 2.
*/
-int MEDCouplingUMesh::AreCellsEqualPolicy2(const int *conn, const int *connI, int cell1, int cell2)
+int MEDCouplingUMesh::AreCellsEqualPolicy2(const mcIdType *conn, const mcIdType *connI, mcIdType cell1, mcIdType cell2)
{
if(connI[cell1+1]-connI[cell1]==connI[cell2+1]-connI[cell2])
{
if(conn[connI[cell1]]==conn[connI[cell2]])
{
- std::set<int> s1(conn+connI[cell1]+1,conn+connI[cell1+1]);
- std::set<int> s2(conn+connI[cell2]+1,conn+connI[cell2+1]);
+ std::set<mcIdType> s1(conn+connI[cell1]+1,conn+connI[cell1+1]);
+ std::set<mcIdType> s2(conn+connI[cell2]+1,conn+connI[cell2+1]);
return s1==s2?1:0;
}
}
/*!
* This method is less restrictive than AreCellsEqualPolicy2. Here the geometric type is absolutely not taken into account !
*/
-int MEDCouplingUMesh::AreCellsEqualPolicy2NoType(const int *conn, const int *connI, int cell1, int cell2)
+int MEDCouplingUMesh::AreCellsEqualPolicy2NoType(const mcIdType *conn, const mcIdType *connI, mcIdType cell1, mcIdType cell2)
{
if(connI[cell1+1]-connI[cell1]==connI[cell2+1]-connI[cell2])
{
- std::set<int> s1(conn+connI[cell1]+1,conn+connI[cell1+1]);
- std::set<int> s2(conn+connI[cell2]+1,conn+connI[cell2+1]);
+ std::set<mcIdType> s1(conn+connI[cell1]+1,conn+connI[cell1+1]);
+ std::set<mcIdType> s2(conn+connI[cell2]+1,conn+connI[cell2+1]);
return s1==s2?1:0;
}
return 0;
/*!
* This method is the last step of the MEDCouplingPointSet::zipConnectivityTraducer with policy 7.
*/
-int MEDCouplingUMesh::AreCellsEqualPolicy7(const int *conn, const int *connI, int cell1, int cell2)
+int MEDCouplingUMesh::AreCellsEqualPolicy7(const mcIdType *conn, const mcIdType *connI, mcIdType cell1, mcIdType cell2)
{
- int sz=connI[cell1+1]-connI[cell1];
+ mcIdType sz=connI[cell1+1]-connI[cell1];
if(sz==connI[cell2+1]-connI[cell2])
{
if(conn[connI[cell1]]==conn[connI[cell2]])
{
if(dim!=1)
{
- int sz1=2*(sz-1);
- INTERP_KERNEL::AutoPtr<int> tmp=new int[sz1];
- int *work=std::copy(conn+connI[cell1]+1,conn+connI[cell1+1],(int *)tmp);
+ mcIdType sz1=2*(sz-1);
+ INTERP_KERNEL::AutoPtr<mcIdType> tmp=new mcIdType[sz1];
+ mcIdType *work=std::copy(conn+connI[cell1]+1,conn+connI[cell1+1],(mcIdType *)tmp);
std::copy(conn+connI[cell1]+1,conn+connI[cell1+1],work);
- work=std::search((int *)tmp,(int *)tmp+sz1,conn+connI[cell2]+1,conn+connI[cell2+1]);
+ work=std::search((mcIdType *)tmp,(mcIdType *)tmp+sz1,conn+connI[cell2]+1,conn+connI[cell2+1]);
if(work!=tmp+sz1)
return 1;
else
{
- std::reverse_iterator<int *> it1((int *)tmp+sz1);
- std::reverse_iterator<int *> it2((int *)tmp);
+ std::reverse_iterator<mcIdType *> it1((mcIdType *)tmp+sz1);
+ std::reverse_iterator<mcIdType *> it2((mcIdType *)tmp);
if(std::search(it1,it2,conn+connI[cell2]+1,conn+connI[cell2+1])!=it2)
return 2;
else
return 1;
if(!cm.isQuadratic())
{
- std::reverse_iterator<const int *> it1(conn+connI[cell1+1]);
- std::reverse_iterator<const int *> it2(conn+connI[cell1]+1);
+ std::reverse_iterator<const mcIdType *> it1(conn+connI[cell1+1]);
+ std::reverse_iterator<const mcIdType *> it2(conn+connI[cell1]+1);
if(std::equal(it1,it2,conn+connI[cell2]+1))
return 2;
return 0;
* \param [out] commonCellsArr common cells ids (\ref numbering-indirect)
* \param [out] commonCellsIArr common cells ids (\ref numbering-indirect)
* \return the correspondence array old to new in a newly allocated array.
- *
+ *
*/
-void MEDCouplingUMesh::findCommonCells(int compType, int startCellId, DataArrayInt *& commonCellsArr, DataArrayInt *& commonCellsIArr) const
+void MEDCouplingUMesh::findCommonCells(int compType, mcIdType startCellId, DataArrayIdType *& commonCellsArr, DataArrayIdType *& commonCellsIArr) const
{
- MCAuto<DataArrayInt> revNodal=DataArrayInt::New(),revNodalI=DataArrayInt::New();
+ MCAuto<DataArrayIdType> revNodal=DataArrayIdType::New(),revNodalI=DataArrayIdType::New();
getReverseNodalConnectivity(revNodal,revNodalI);
FindCommonCellsAlg(compType,startCellId,_nodal_connec,_nodal_connec_index,revNodal,revNodalI,commonCellsArr,commonCellsIArr);
}
-void MEDCouplingUMesh::FindCommonCellsAlg(int compType, int startCellId, const DataArrayInt *nodal, const DataArrayInt *nodalI, const DataArrayInt *revNodal, const DataArrayInt *revNodalI,
- DataArrayInt *& commonCellsArr, DataArrayInt *& commonCellsIArr)
+void MEDCouplingUMesh::FindCommonCellsAlg(int compType, mcIdType startCellId, const DataArrayIdType *nodal, const DataArrayIdType *nodalI, const DataArrayIdType *revNodal, const DataArrayIdType *revNodalI,
+ DataArrayIdType *& commonCellsArr, DataArrayIdType *& commonCellsIArr)
{
- MCAuto<DataArrayInt> commonCells=DataArrayInt::New(),commonCellsI=DataArrayInt::New(); commonCells->alloc(0,1);
- int nbOfCells=nodalI->getNumberOfTuples()-1;
+ MCAuto<DataArrayIdType> commonCells=DataArrayIdType::New(),commonCellsI=DataArrayIdType::New(); commonCells->alloc(0,1);
+ mcIdType nbOfCells=nodalI->getNumberOfTuples()-1;
commonCellsI->reserve(1); commonCellsI->pushBackSilent(0);
- const int *revNodalPtr=revNodal->getConstPointer(),*revNodalIPtr=revNodalI->getConstPointer();
- const int *connPtr=nodal->getConstPointer(),*connIPtr=nodalI->getConstPointer();
+ const mcIdType *revNodalPtr=revNodal->getConstPointer(),*revNodalIPtr=revNodalI->getConstPointer();
+ const mcIdType *connPtr=nodal->getConstPointer(),*connIPtr=nodalI->getConstPointer();
std::vector<bool> isFetched(nbOfCells,false);
if(startCellId==0)
{
- for(int i=0;i<nbOfCells;i++)
+ for(mcIdType i=0;i<nbOfCells;i++)
{
if(!isFetched[i])
{
- const int *connOfNode=std::find_if(connPtr+connIPtr[i]+1,connPtr+connIPtr[i+1],std::bind2nd(std::not_equal_to<int>(),-1));
- std::vector<int> v,v2;
+ const mcIdType *connOfNode=std::find_if(connPtr+connIPtr[i]+1,connPtr+connIPtr[i+1],std::bind2nd(std::not_equal_to<mcIdType>(),-1));
+ std::vector<mcIdType> v,v2;
if(connOfNode!=connPtr+connIPtr[i+1])
{
- const int *locRevNodal=std::find(revNodalPtr+revNodalIPtr[*connOfNode],revNodalPtr+revNodalIPtr[*connOfNode+1],i);
+ const mcIdType *locRevNodal=std::find(revNodalPtr+revNodalIPtr[*connOfNode],revNodalPtr+revNodalIPtr[*connOfNode+1],i);
v2.insert(v2.end(),locRevNodal,revNodalPtr+revNodalIPtr[*connOfNode+1]);
connOfNode++;
}
if(*connOfNode>=0)
{
v=v2;
- const int *locRevNodal=std::find(revNodalPtr+revNodalIPtr[*connOfNode],revNodalPtr+revNodalIPtr[*connOfNode+1],i);
- std::vector<int>::iterator it=std::set_intersection(v.begin(),v.end(),locRevNodal,revNodalPtr+revNodalIPtr[*connOfNode+1],v2.begin());
+ const mcIdType *locRevNodal=std::find(revNodalPtr+revNodalIPtr[*connOfNode],revNodalPtr+revNodalIPtr[*connOfNode+1],i);
+ std::vector<mcIdType>::iterator it=std::set_intersection(v.begin(),v.end(),locRevNodal,revNodalPtr+revNodalIPtr[*connOfNode+1],v2.begin());
v2.resize(std::distance(v2.begin(),it));
}
if(v2.size()>1)
{
if(AreCellsEqualInPool(v2,compType,connPtr,connIPtr,commonCells))
{
- int pos=commonCellsI->back();
+ mcIdType pos=commonCellsI->back();
commonCellsI->pushBackSilent(commonCells->getNumberOfTuples());
- for(const int *it=commonCells->begin()+pos;it!=commonCells->end();it++)
+ for(const mcIdType *it=commonCells->begin()+pos;it!=commonCells->end();it++)
isFetched[*it]=true;
}
}
}
else
{
- for(int i=startCellId;i<nbOfCells;i++)
+ for(mcIdType i=startCellId;i<nbOfCells;i++)
{
if(!isFetched[i])
{
- const int *connOfNode=std::find_if(connPtr+connIPtr[i]+1,connPtr+connIPtr[i+1],std::bind2nd(std::not_equal_to<int>(),-1));
- std::vector<int> v,v2;
+ const mcIdType *connOfNode=std::find_if(connPtr+connIPtr[i]+1,connPtr+connIPtr[i+1],std::bind2nd(std::not_equal_to<mcIdType>(),-1));
+ std::vector<mcIdType> v,v2;
if(connOfNode!=connPtr+connIPtr[i+1])
{
v2.insert(v2.end(),revNodalPtr+revNodalIPtr[*connOfNode],revNodalPtr+revNodalIPtr[*connOfNode+1]);
if(*connOfNode>=0)
{
v=v2;
- std::vector<int>::iterator it=std::set_intersection(v.begin(),v.end(),revNodalPtr+revNodalIPtr[*connOfNode],revNodalPtr+revNodalIPtr[*connOfNode+1],v2.begin());
+ std::vector<mcIdType>::iterator it=std::set_intersection(v.begin(),v.end(),revNodalPtr+revNodalIPtr[*connOfNode],revNodalPtr+revNodalIPtr[*connOfNode+1],v2.begin());
v2.resize(std::distance(v2.begin(),it));
}
if(v2.size()>1)
{
if(AreCellsEqualInPool(v2,compType,connPtr,connIPtr,commonCells))
{
- int pos=commonCellsI->back();
+ mcIdType pos=commonCellsI->back();
commonCellsI->pushBackSilent(commonCells->getNumberOfTuples());
- for(const int *it=commonCells->begin()+pos;it!=commonCells->end();it++)
+ for(const mcIdType *it=commonCells->begin()+pos;it!=commonCells->end();it++)
isFetched[*it]=true;
}
}
* than \a this->getNumberOfCells() in the returned array means that there is no
* corresponding cell in \a this mesh.
* It is expected that \a this and \a other meshes share the same node coordinates
- * array, if it is not so an exception is thrown.
+ * array, if it is not so an exception is thrown.
* \param [in] other - the mesh to compare with.
* \param [in] compType - specifies a cell comparison technique. For meaning of its
* valid values [0,1,2], see zipConnectivityTraducer().
- * \param [out] arr - a new instance of DataArrayInt returning correspondence
+ * \param [out] arr - a new instance of DataArrayIdType returning correspondence
* between cells of the two meshes. It contains \a other->getNumberOfCells()
* values. The caller is to delete this array using
* decrRef() as it is no more needed.
* \sa checkDeepEquivalOnSameNodesWith()
* \sa checkGeoEquivalWith()
*/
-bool MEDCouplingUMesh::areCellsIncludedIn(const MEDCouplingUMesh *other, int compType, DataArrayInt *& arr) const
+bool MEDCouplingUMesh::areCellsIncludedIn(const MEDCouplingUMesh *other, int compType, DataArrayIdType *& arr) const
{
MCAuto<MEDCouplingUMesh> mesh=MergeUMeshesOnSameCoords(this,other);
- int nbOfCells=getNumberOfCells();
+ mcIdType nbOfCells=getNumberOfCells();
static const int possibleCompType[]={0,1,2};
if(std::find(possibleCompType,possibleCompType+sizeof(possibleCompType)/sizeof(int),compType)==possibleCompType+sizeof(possibleCompType)/sizeof(int))
{
oss << " !";
throw INTERP_KERNEL::Exception(oss.str());
}
- MCAuto<DataArrayInt> o2n=mesh->zipConnectivityTraducer(compType,nbOfCells);
+ MCAuto<DataArrayIdType> o2n=mesh->zipConnectivityTraducer(compType,nbOfCells);
arr=o2n->subArray(nbOfCells);
arr->setName(other->getName());
- int tmp;
+ mcIdType tmp;
if(other->getNumberOfCells()==0)
return true;
return arr->getMaxValue(tmp)<nbOfCells;
* \param arr is an output parameter that returns a \b newly created instance. This array is of size 'other->getNumberOfCells()'.
* \return If \a other is fully included in 'this 'true is returned. If not false is returned.
*/
-bool MEDCouplingUMesh::areCellsIncludedInPolicy7(const MEDCouplingUMesh *other, DataArrayInt *& arr) const
+bool MEDCouplingUMesh::areCellsIncludedInPolicy7(const MEDCouplingUMesh *other, DataArrayIdType *& arr) const
{
MCAuto<MEDCouplingUMesh> mesh=MergeUMeshesOnSameCoords(this,other);
- DataArrayInt *commonCells=0,*commonCellsI=0;
- int thisNbCells=getNumberOfCells();
+ DataArrayIdType *commonCells=0,*commonCellsI=0;
+ mcIdType thisNbCells=getNumberOfCells();
mesh->findCommonCells(7,thisNbCells,commonCells,commonCellsI);
- MCAuto<DataArrayInt> commonCellsTmp(commonCells),commonCellsITmp(commonCellsI);
- const int *commonCellsPtr=commonCells->getConstPointer(),*commonCellsIPtr=commonCellsI->getConstPointer();
- int otherNbCells=other->getNumberOfCells();
- MCAuto<DataArrayInt> arr2=DataArrayInt::New();
+ MCAuto<DataArrayIdType> commonCellsTmp(commonCells),commonCellsITmp(commonCellsI);
+ const mcIdType *commonCellsPtr=commonCells->getConstPointer(),*commonCellsIPtr=commonCellsI->getConstPointer();
+ mcIdType otherNbCells=other->getNumberOfCells();
+ MCAuto<DataArrayIdType> arr2=DataArrayIdType::New();
arr2->alloc(otherNbCells,1);
arr2->fillWithZero();
- int *arr2Ptr=arr2->getPointer();
- int nbOfCommon=commonCellsI->getNumberOfTuples()-1;
- for(int i=0;i<nbOfCommon;i++)
+ mcIdType *arr2Ptr=arr2->getPointer();
+ mcIdType nbOfCommon=commonCellsI->getNumberOfTuples()-1;
+ for(mcIdType i=0;i<nbOfCommon;i++)
{
- int start=commonCellsPtr[commonCellsIPtr[i]];
+ mcIdType start=commonCellsPtr[commonCellsIPtr[i]];
if(start<thisNbCells)
{
- for(int j=commonCellsIPtr[i]+1;j!=commonCellsIPtr[i+1];j++)
+ for(mcIdType j=commonCellsIPtr[i]+1;j!=commonCellsIPtr[i+1];j++)
{
- int sig=commonCellsPtr[j]>0?1:-1;
- int val=std::abs(commonCellsPtr[j])-1;
+ mcIdType sig=commonCellsPtr[j]>0?1:-1;
+ mcIdType val=std::abs(commonCellsPtr[j])-1;
if(val>=thisNbCells)
arr2Ptr[val-thisNbCells]=sig*(start+1);
}
* Build a sub part of \b this lying or not on the same coordinates than \b this (regarding value of \b keepCoords).
* By default coordinates are kept. This method is close to MEDCouplingUMesh::buildPartOfMySelf except that here input
* cellIds is not given explicitly but by a range python like.
- *
+ *
* \param start
* \param end
* \param step
* \param keepCoords that specifies if you want or not to keep coords as this or zip it (see MEDCoupling::MEDCouplingUMesh::zipCoords). If true zipCoords is \b NOT called, if false, zipCoords is called.
* \return a newly allocated
- *
+ *
* \warning This method modifies can generate an unstructured mesh whose cells are not sorted by geometric type order.
* In view of the MED file writing, a renumbering of cells of returned unstructured mesh (using MEDCouplingUMesh::sortCellsInMEDFileFrmt) should be necessary.
*/
-MEDCouplingUMesh *MEDCouplingUMesh::buildPartOfMySelfSlice(int start, int end, int step, bool keepCoords) const
+MEDCouplingUMesh *MEDCouplingUMesh::buildPartOfMySelfSlice(mcIdType start, mcIdType end, mcIdType step, bool keepCoords) const
{
if(getMeshDimension()!=-1)
return static_cast<MEDCouplingUMesh *>(MEDCouplingPointSet::buildPartOfMySelfSlice(start,end,step,keepCoords));
else
{
- int newNbOfCells=DataArray::GetNumberOfItemGivenBESRelative(start,end,step,"MEDCouplingUMesh::buildPartOfMySelfSlice for -1 dimension mesh ");
+ mcIdType newNbOfCells=DataArray::GetNumberOfItemGivenBESRelative(start,end,step,"MEDCouplingUMesh::buildPartOfMySelfSlice for -1 dimension mesh ");
if(newNbOfCells!=1)
throw INTERP_KERNEL::Exception("-1D mesh has only one cell !");
if(start!=0)
* array of \a this mesh, else "free" nodes are removed from the result mesh
* by calling zipCoords().
* \return MEDCouplingUMesh * - a new instance of MEDCouplingUMesh. The caller is
- * to delete this mesh using decrRef() as it is no more needed.
+ * to delete this mesh using decrRef() as it is no more needed.
* \throw If the coordinates array is not set.
* \throw If the nodal connectivity of cells is not defined.
* \throw If any cell id in the array \a begin is not valid.
* \ref py_mcumesh_buildPartOfMySelf "Here is a Python example".
* \endif
*/
-MEDCouplingUMesh *MEDCouplingUMesh::buildPartOfMySelf(const int *begin, const int *end, bool keepCoords) const
+MEDCouplingUMesh *MEDCouplingUMesh::buildPartOfMySelf(const mcIdType *begin, const mcIdType *end, bool keepCoords) const
{
if(getMeshDimension()!=-1)
return static_cast<MEDCouplingUMesh *>(MEDCouplingPointSet::buildPartOfMySelf(begin,end,keepCoords));
* \param [in] otherOnSameCoordsThanThis an another mesh with same meshdimension than \b this with exactly the same number of cells than cell ids list in [\b cellIdsBg, \b cellIdsEnd ).
* Coordinate pointer of \b this and those of \b otherOnSameCoordsThanThis must be the same
*/
-void MEDCouplingUMesh::setPartOfMySelf(const int *cellIdsBg, const int *cellIdsEnd, const MEDCouplingUMesh& otherOnSameCoordsThanThis)
+void MEDCouplingUMesh::setPartOfMySelf(const mcIdType *cellIdsBg, const mcIdType *cellIdsEnd, const MEDCouplingUMesh& otherOnSameCoordsThanThis)
{
checkConnectivityFullyDefined();
otherOnSameCoordsThanThis.checkConnectivityFullyDefined();
oss << ", whereas other mesh dimension is set equal to " << otherOnSameCoordsThanThis.getMeshDimension() << " !";
throw INTERP_KERNEL::Exception(oss.str());
}
- std::size_t nbOfCellsToModify(std::distance(cellIdsBg,cellIdsEnd));
+ mcIdType nbOfCellsToModify( ToIdType((std::distance(cellIdsBg,cellIdsEnd))));
if(nbOfCellsToModify!=otherOnSameCoordsThanThis.getNumberOfCells())
{
std::ostringstream oss; oss << "MEDCouplingUMesh::setPartOfMySelf : cells ids length (" << nbOfCellsToModify << ") do not match the number of cells of other mesh (" << otherOnSameCoordsThanThis.getNumberOfCells() << ") !";
throw INTERP_KERNEL::Exception(oss.str());
}
- std::size_t nbOfCells(getNumberOfCells());
+ mcIdType nbOfCells(getNumberOfCells());
bool easyAssign(true);
- const int *connI(_nodal_connec_index->begin());
- const int *connIOther=otherOnSameCoordsThanThis._nodal_connec_index->begin();
- for(const int *it=cellIdsBg;it!=cellIdsEnd && easyAssign;it++,connIOther++)
+ const mcIdType *connI(_nodal_connec_index->begin());
+ const mcIdType *connIOther=otherOnSameCoordsThanThis._nodal_connec_index->begin();
+ for(const mcIdType *it=cellIdsBg;it!=cellIdsEnd && easyAssign;it++,connIOther++)
{
- if(*it>=0 && *it<(int)nbOfCells)
+ if(*it>=0 && *it<nbOfCells)
{
easyAssign=(connIOther[1]-connIOther[0])==(connI[*it+1]-connI[*it]);
}
}
if(easyAssign)
{
- MEDCouplingUMesh::SetPartOfIndexedArraysSameIdx(cellIdsBg,cellIdsEnd,_nodal_connec,_nodal_connec_index,otherOnSameCoordsThanThis._nodal_connec,otherOnSameCoordsThanThis._nodal_connec_index);
+ DataArrayIdType::SetPartOfIndexedArraysSameIdx(cellIdsBg,cellIdsEnd,_nodal_connec,_nodal_connec_index,otherOnSameCoordsThanThis._nodal_connec,otherOnSameCoordsThanThis._nodal_connec_index);
computeTypes();
}
else
{
- DataArrayInt *arrOut=0,*arrIOut=0;
- MEDCouplingUMesh::SetPartOfIndexedArrays(cellIdsBg,cellIdsEnd,_nodal_connec,_nodal_connec_index,otherOnSameCoordsThanThis._nodal_connec,otherOnSameCoordsThanThis._nodal_connec_index,
+ DataArrayIdType *arrOut=0,*arrIOut=0;
+ DataArrayIdType::SetPartOfIndexedArrays(cellIdsBg,cellIdsEnd,_nodal_connec,_nodal_connec_index,otherOnSameCoordsThanThis._nodal_connec,otherOnSameCoordsThanThis._nodal_connec_index,
arrOut,arrIOut);
- MCAuto<DataArrayInt> arrOutAuto(arrOut),arrIOutAuto(arrIOut);
+ MCAuto<DataArrayIdType> arrOutAuto(arrOut),arrIOutAuto(arrIOut);
setConnectivity(arrOut,arrIOut,true);
}
}
-void MEDCouplingUMesh::setPartOfMySelfSlice(int start, int end, int step, const MEDCouplingUMesh& otherOnSameCoordsThanThis)
+void MEDCouplingUMesh::setPartOfMySelfSlice(mcIdType start, mcIdType end, mcIdType step, const MEDCouplingUMesh& otherOnSameCoordsThanThis)
{
checkConnectivityFullyDefined();
otherOnSameCoordsThanThis.checkConnectivityFullyDefined();
oss << ", whereas other mesh dimension is set equal to " << otherOnSameCoordsThanThis.getMeshDimension() << " !";
throw INTERP_KERNEL::Exception(oss.str());
}
- int nbOfCellsToModify=DataArray::GetNumberOfItemGivenBESRelative(start,end,step,"MEDCouplingUMesh::setPartOfMySelfSlice : ");
- if(nbOfCellsToModify!=(int)otherOnSameCoordsThanThis.getNumberOfCells())
+ mcIdType nbOfCellsToModify=DataArray::GetNumberOfItemGivenBESRelative(start,end,step,"MEDCouplingUMesh::setPartOfMySelfSlice : ");
+ if(nbOfCellsToModify!=otherOnSameCoordsThanThis.getNumberOfCells())
{
std::ostringstream oss; oss << "MEDCouplingUMesh::setPartOfMySelfSlice : cells ids length (" << nbOfCellsToModify << ") do not match the number of cells of other mesh (" << otherOnSameCoordsThanThis.getNumberOfCells() << ") !";
throw INTERP_KERNEL::Exception(oss.str());
}
- int nbOfCells=getNumberOfCells();
+ mcIdType nbOfCells=getNumberOfCells();
bool easyAssign=true;
- const int *connI=_nodal_connec_index->getConstPointer();
- const int *connIOther=otherOnSameCoordsThanThis._nodal_connec_index->getConstPointer();
- int it=start;
- for(int i=0;i<nbOfCellsToModify && easyAssign;i++,it+=step,connIOther++)
+ const mcIdType *connI=_nodal_connec_index->getConstPointer();
+ const mcIdType *connIOther=otherOnSameCoordsThanThis._nodal_connec_index->getConstPointer();
+ mcIdType it=start;
+ for(mcIdType i=0;i<nbOfCellsToModify && easyAssign;i++,it+=step,connIOther++)
{
if(it>=0 && it<nbOfCells)
{
}
if(easyAssign)
{
- MEDCouplingUMesh::SetPartOfIndexedArraysSameIdxSlice(start,end,step,_nodal_connec,_nodal_connec_index,otherOnSameCoordsThanThis._nodal_connec,otherOnSameCoordsThanThis._nodal_connec_index);
+ DataArrayIdType::SetPartOfIndexedArraysSameIdxSlice(start,end,step,_nodal_connec,_nodal_connec_index,otherOnSameCoordsThanThis._nodal_connec,otherOnSameCoordsThanThis._nodal_connec_index);
computeTypes();
}
else
{
- DataArrayInt *arrOut=0,*arrIOut=0;
- MEDCouplingUMesh::SetPartOfIndexedArraysSlice(start,end,step,_nodal_connec,_nodal_connec_index,otherOnSameCoordsThanThis._nodal_connec,otherOnSameCoordsThanThis._nodal_connec_index,
+ DataArrayIdType *arrOut=0,*arrIOut=0;
+ DataArrayIdType::SetPartOfIndexedArraysSlice(start,end,step,_nodal_connec,_nodal_connec_index,otherOnSameCoordsThanThis._nodal_connec,otherOnSameCoordsThanThis._nodal_connec_index,
arrOut,arrIOut);
- MCAuto<DataArrayInt> arrOutAuto(arrOut),arrIOutAuto(arrIOut);
+ MCAuto<DataArrayIdType> arrOutAuto(arrOut),arrIOutAuto(arrIOut);
setConnectivity(arrOut,arrIOut,true);
}
-}
+}
/*!
* specified node ids and the value of \a fullyIn parameter. If \a fullyIn ==\c true, a
* cell is copied if its all nodes are in the array \a begin of node ids. If \a fullyIn
* ==\c false, a cell is copied if any its node is in the array of node ids. The
- * created mesh shares the node coordinates array with \a this mesh.
+ * created mesh shares the node coordinates array with \a this mesh.
* \param [in] begin - the array of node ids.
* \param [in] end - a pointer to the (last+1)-th element of \a begin.
* \param [in] fullyIn - if \c true, then cells whose all nodes are in the
* array \a begin are added, else cells whose any node is in the
* array \a begin are added.
* \return MEDCouplingUMesh * - new instance of MEDCouplingUMesh. The caller is
- * to delete this mesh using decrRef() as it is no more needed.
+ * to delete this mesh using decrRef() as it is no more needed.
* \throw If the coordinates array is not set.
* \throw If the nodal connectivity of cells is not defined.
* \throw If any node id in \a begin is not valid.
* \ref py_mcumesh_buildFacePartOfMySelfNode "Here is a Python example".
* \endif
*/
-MEDCouplingUMesh *MEDCouplingUMesh::buildFacePartOfMySelfNode(const int *begin, const int *end, bool fullyIn) const
+MEDCouplingUMesh *MEDCouplingUMesh::buildFacePartOfMySelfNode(const mcIdType *begin, const mcIdType *end, bool fullyIn) const
{
- MCAuto<DataArrayInt> desc,descIndx,revDesc,revDescIndx;
- desc=DataArrayInt::New(); descIndx=DataArrayInt::New(); revDesc=DataArrayInt::New(); revDescIndx=DataArrayInt::New();
+ MCAuto<DataArrayIdType> desc,descIndx,revDesc,revDescIndx;
+ desc=DataArrayIdType::New(); descIndx=DataArrayIdType::New(); revDesc=DataArrayIdType::New(); revDescIndx=DataArrayIdType::New();
MCAuto<MEDCouplingUMesh> subMesh=buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
desc=0; descIndx=0; revDesc=0; revDescIndx=0;
return static_cast<MEDCouplingUMesh*>(subMesh->buildPartOfMySelfNode(begin,end,fullyIn));
* array of \a this mesh, else "free" nodes are removed from the result mesh
* by calling zipCoords().
* \return MEDCouplingUMesh * - a new instance of MEDCouplingUMesh. The caller is
- * to delete this mesh using decrRef() as it is no more needed.
+ * to delete this mesh using decrRef() as it is no more needed.
* \throw If the coordinates array is not set.
* \throw If the nodal connectivity of cells is not defined.
*
*/
MEDCouplingUMesh *MEDCouplingUMesh::buildBoundaryMesh(bool keepCoords) const
{
- DataArrayInt *desc=DataArrayInt::New();
- DataArrayInt *descIndx=DataArrayInt::New();
- DataArrayInt *revDesc=DataArrayInt::New();
- DataArrayInt *revDescIndx=DataArrayInt::New();
+ DataArrayIdType *desc=DataArrayIdType::New();
+ DataArrayIdType *descIndx=DataArrayIdType::New();
+ DataArrayIdType *revDesc=DataArrayIdType::New();
+ DataArrayIdType *revDescIndx=DataArrayIdType::New();
//
MCAuto<MEDCouplingUMesh> meshDM1=buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
revDesc->decrRef();
desc->decrRef();
descIndx->decrRef();
- int nbOfCells=meshDM1->getNumberOfCells();
- const int *revDescIndxC=revDescIndx->getConstPointer();
- std::vector<int> boundaryCells;
- for(int i=0;i<nbOfCells;i++)
+ mcIdType nbOfCells=meshDM1->getNumberOfCells();
+ const mcIdType *revDescIndxC=revDescIndx->getConstPointer();
+ std::vector<mcIdType> boundaryCells;
+ for(mcIdType i=0;i<nbOfCells;i++)
if(revDescIndxC[i+1]-revDescIndxC[i]==1)
boundaryCells.push_back(i);
revDescIndx->decrRef();
}
/*!
- * This method returns a newly created DataArrayInt instance containing ids of cells located in boundary.
+ * This method returns a newly created DataArrayIdType instance containing ids of cells located in boundary.
* A cell is detected to be on boundary if it contains one or more than one face having only one father.
- * This method makes the assumption that \a this is fully defined (coords,connectivity). If not an exception will be thrown.
+ * This method makes the assumption that \a this is fully defined (coords,connectivity). If not an exception will be thrown.
*/
-DataArrayInt *MEDCouplingUMesh::findCellIdsOnBoundary() const
+DataArrayIdType *MEDCouplingUMesh::findCellIdsOnBoundary() const
{
checkFullyDefined();
- MCAuto<DataArrayInt> desc=DataArrayInt::New();
- MCAuto<DataArrayInt> descIndx=DataArrayInt::New();
- MCAuto<DataArrayInt> revDesc=DataArrayInt::New();
- MCAuto<DataArrayInt> revDescIndx=DataArrayInt::New();
+ MCAuto<DataArrayIdType> desc=DataArrayIdType::New();
+ MCAuto<DataArrayIdType> descIndx=DataArrayIdType::New();
+ MCAuto<DataArrayIdType> revDesc=DataArrayIdType::New();
+ MCAuto<DataArrayIdType> revDescIndx=DataArrayIdType::New();
//
buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx)->decrRef();
- desc=(DataArrayInt*)0; descIndx=(DataArrayInt*)0;
+ desc=(DataArrayIdType*)0; descIndx=(DataArrayIdType*)0;
//
- MCAuto<DataArrayInt> tmp=revDescIndx->deltaShiftIndex();
- MCAuto<DataArrayInt> faceIds=tmp->findIdsEqual(1); tmp=(DataArrayInt*)0;
- const int *revDescPtr=revDesc->getConstPointer();
- const int *revDescIndxPtr=revDescIndx->getConstPointer();
- int nbOfCells=getNumberOfCells();
+ MCAuto<DataArrayIdType> tmp=revDescIndx->deltaShiftIndex();
+ MCAuto<DataArrayIdType> faceIds=tmp->findIdsEqual(1); tmp=(DataArrayIdType*)0;
+ const mcIdType *revDescPtr=revDesc->getConstPointer();
+ const mcIdType *revDescIndxPtr=revDescIndx->getConstPointer();
+ mcIdType nbOfCells=getNumberOfCells();
std::vector<bool> ret1(nbOfCells,false);
- int sz=0;
- for(const int *pt=faceIds->begin();pt!=faceIds->end();pt++)
+ mcIdType sz=0;
+ for(const mcIdType *pt=faceIds->begin();pt!=faceIds->end();pt++)
if(!ret1[revDescPtr[revDescIndxPtr[*pt]]])
{ ret1[revDescPtr[revDescIndxPtr[*pt]]]=true; sz++; }
//
- DataArrayInt *ret2=DataArrayInt::New();
+ DataArrayIdType *ret2=DataArrayIdType::New();
ret2->alloc(sz,1);
- int *ret2Ptr=ret2->getPointer();
+ mcIdType *ret2Ptr=ret2->getPointer();
sz=0;
for(std::vector<bool>::const_iterator it=ret1.begin();it!=ret1.end();it++,sz++)
if(*it)
* \param [out] cellIdsRk1 a newly allocated array containing the cell ids of s1 \b indexed into the \b cellIdsRk0 subset. To get the absolute ids of s1, simply invoke
* cellIdsRk1->transformWithIndArr(cellIdsRk0->begin(),cellIdsRk0->end());
*/
-void MEDCouplingUMesh::findCellIdsLyingOn(const MEDCouplingUMesh& otherDimM1OnSameCoords, DataArrayInt *&cellIdsRk0, DataArrayInt *&cellIdsRk1) const
+void MEDCouplingUMesh::findCellIdsLyingOn(const MEDCouplingUMesh& otherDimM1OnSameCoords, DataArrayIdType *&cellIdsRk0, DataArrayIdType *&cellIdsRk1) const
{
if(getCoords()!=otherDimM1OnSameCoords.getCoords())
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::findCellIdsLyingOn : coordinates pointer are not the same ! Use tryToShareSameCoords method !");
otherDimM1OnSameCoords.checkConnectivityFullyDefined();
if(getMeshDimension()-1!=otherDimM1OnSameCoords.getMeshDimension())
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::findCellIdsLyingOn : invalid mesh dimension of input mesh regarding meshdimesion of this !");
- MCAuto<DataArrayInt> fetchedNodeIds1=otherDimM1OnSameCoords.computeFetchedNodeIds();
- MCAuto<DataArrayInt> s0arr=getCellIdsLyingOnNodes(fetchedNodeIds1->begin(),fetchedNodeIds1->end(),false);
+ MCAuto<DataArrayIdType> fetchedNodeIds1=otherDimM1OnSameCoords.computeFetchedNodeIds();
+ MCAuto<DataArrayIdType> s0arr=getCellIdsLyingOnNodes(fetchedNodeIds1->begin(),fetchedNodeIds1->end(),false);
MCAuto<MEDCouplingUMesh> thisPart=static_cast<MEDCouplingUMesh *>(buildPartOfMySelf(s0arr->begin(),s0arr->end(),true));
- MCAuto<DataArrayInt> descThisPart=DataArrayInt::New(),descIThisPart=DataArrayInt::New(),revDescThisPart=DataArrayInt::New(),revDescIThisPart=DataArrayInt::New();
+ MCAuto<DataArrayIdType> descThisPart=DataArrayIdType::New(),descIThisPart=DataArrayIdType::New(),revDescThisPart=DataArrayIdType::New(),revDescIThisPart=DataArrayIdType::New();
MCAuto<MEDCouplingUMesh> thisPartConsti=thisPart->buildDescendingConnectivity(descThisPart,descIThisPart,revDescThisPart,revDescIThisPart);
- const int *revDescThisPartPtr=revDescThisPart->getConstPointer(),*revDescIThisPartPtr=revDescIThisPart->getConstPointer();
- DataArrayInt *idsOtherInConsti=0;
+ const mcIdType *revDescThisPartPtr=revDescThisPart->getConstPointer(),*revDescIThisPartPtr=revDescIThisPart->getConstPointer();
+ DataArrayIdType *idsOtherInConsti=0;
bool b=thisPartConsti->areCellsIncludedIn(&otherDimM1OnSameCoords,2,idsOtherInConsti);
- MCAuto<DataArrayInt> idsOtherInConstiAuto(idsOtherInConsti);
+ MCAuto<DataArrayIdType> idsOtherInConstiAuto(idsOtherInConsti);
if(!b)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::findCellIdsLyingOn : the given mdim-1 mesh in other is not a constituent of this !");
- std::set<int> s1;
- for(const int *idOther=idsOtherInConsti->begin();idOther!=idsOtherInConsti->end();idOther++)
+ std::set<mcIdType> s1;
+ for(const mcIdType *idOther=idsOtherInConsti->begin();idOther!=idsOtherInConsti->end();idOther++)
s1.insert(revDescThisPartPtr+revDescIThisPartPtr[*idOther],revDescThisPartPtr+revDescIThisPartPtr[*idOther+1]);
- MCAuto<DataArrayInt> s1arr_renum1=DataArrayInt::New(); s1arr_renum1->alloc((int)s1.size(),1); std::copy(s1.begin(),s1.end(),s1arr_renum1->getPointer());
+ MCAuto<DataArrayIdType> s1arr_renum1=DataArrayIdType::New(); s1arr_renum1->alloc(s1.size(),1); std::copy(s1.begin(),s1.end(),s1arr_renum1->getPointer());
s1arr_renum1->sort();
cellIdsRk0=s0arr.retn();
//cellIdsRk1=s_renum1.retn();
/*!
* This method computes the skin of \b this. That is to say the consituting meshdim-1 mesh is built and only the boundary subpart is
* returned. This subpart of meshdim-1 mesh is built using meshdim-1 cells in it shared only one cell in \b this.
- *
+ *
* \return a newly allocated mesh lying on the same coordinates than \b this. The caller has to deal with returned mesh.
*/
MEDCouplingUMesh *MEDCouplingUMesh::computeSkin() const
{
- MCAuto<DataArrayInt> desc=DataArrayInt::New();
- MCAuto<DataArrayInt> descIndx=DataArrayInt::New();
- MCAuto<DataArrayInt> revDesc=DataArrayInt::New();
- MCAuto<DataArrayInt> revDescIndx=DataArrayInt::New();
+ MCAuto<DataArrayIdType> desc=DataArrayIdType::New();
+ MCAuto<DataArrayIdType> descIndx=DataArrayIdType::New();
+ MCAuto<DataArrayIdType> revDesc=DataArrayIdType::New();
+ MCAuto<DataArrayIdType> revDescIndx=DataArrayIdType::New();
//
MCAuto<MEDCouplingUMesh> meshDM1=buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx);
revDesc=0; desc=0; descIndx=0;
- MCAuto<DataArrayInt> revDescIndx2=revDescIndx->deltaShiftIndex();
- MCAuto<DataArrayInt> part=revDescIndx2->findIdsEqual(1);
+ MCAuto<DataArrayIdType> revDescIndx2=revDescIndx->deltaShiftIndex();
+ MCAuto<DataArrayIdType> part=revDescIndx2->findIdsEqual(1);
return static_cast<MEDCouplingUMesh *>(meshDM1->buildPartOfMySelf(part->begin(),part->end(),true));
}
/*!
* Finds nodes lying on the boundary of \a this mesh.
- * \return DataArrayInt * - a new instance of DataArrayInt holding ids of found
+ * \return DataArrayIdType * - a new instance of DataArrayIdType holding ids of found
* nodes. The caller is to delete this array using decrRef() as it is no
* more needed.
* \throw If the coordinates array is not set.
* \ref py_mcumesh_findBoundaryNodes "Here is a Python example".
* \endif
*/
-DataArrayInt *MEDCouplingUMesh::findBoundaryNodes() const
+DataArrayIdType *MEDCouplingUMesh::findBoundaryNodes() const
{
MCAuto<MEDCouplingUMesh> skin=computeSkin();
return skin->computeFetchedNodeIds();
* parameter is altered during the call.
* \param [out] nodeIdsToDuplicate node ids needed to be duplicated following the algorithm explain above.
* \param [out] cellIdsNeededToBeRenum cell ids in \b this in which the renumber of nodes should be performed.
- * \param [out] cellIdsNotModified cell ids int \b this that lies on \b otherDimM1OnSameCoords mesh whose connectivity do \b not need to be modified as it is the case for \b cellIdsNeededToBeRenum.
+ * \param [out] cellIdsNotModified cell ids mcIdType \b this that lies on \b otherDimM1OnSameCoords mesh whose connectivity do \b not need to be modified as it is the case for \b cellIdsNeededToBeRenum.
*
* \warning This method modifies param \b otherDimM1OnSameCoords (for speed reasons).
*/
-void MEDCouplingUMesh::findNodesToDuplicate(const MEDCouplingUMesh& otherDimM1OnSameCoords, DataArrayInt *& nodeIdsToDuplicate,
- DataArrayInt *& cellIdsNeededToBeRenum, DataArrayInt *& cellIdsNotModified) const
+void MEDCouplingUMesh::findNodesToDuplicate(const MEDCouplingUMesh& otherDimM1OnSameCoords, DataArrayIdType *& nodeIdsToDuplicate,
+ DataArrayIdType *& cellIdsNeededToBeRenum, DataArrayIdType *& cellIdsNotModified) const
{
- typedef MCAuto<DataArrayInt> DAInt;
+ typedef MCAuto<DataArrayIdType> DAInt;
typedef MCAuto<MEDCouplingUMesh> MCUMesh;
checkFullyDefined();
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::findNodesToDuplicate : the mesh given in other parameter must have this->getMeshDimension()-1 !");
// Checking star-shaped M1 group:
- DAInt dt0=DataArrayInt::New(),dit0=DataArrayInt::New(),rdt0=DataArrayInt::New(),rdit0=DataArrayInt::New();
+ DAInt dt0=DataArrayIdType::New(),dit0=DataArrayIdType::New(),rdt0=DataArrayIdType::New(),rdit0=DataArrayIdType::New();
MCUMesh meshM2 = otherDimM1OnSameCoords.buildDescendingConnectivity(dt0, dit0, rdt0, rdit0);
DAInt dsi = rdit0->deltaShiftIndex();
DAInt idsTmp0 = dsi->findIdsNotInRange(-1, 3);
MCUMesh meshM2Part = static_cast<MEDCouplingUMesh *>(meshM2->buildPartOfMySelf(xtremIdsM2->begin(), xtremIdsM2->end(),true));
DAInt xtrem = meshM2Part->computeFetchedNodeIds();
// Remove from the list points on the boundary of the M0 mesh (those need duplication!)
- dt0=DataArrayInt::New(),dit0=DataArrayInt::New(),rdt0=DataArrayInt::New(),rdit0=DataArrayInt::New();
+ dt0=DataArrayIdType::New(),dit0=DataArrayIdType::New(),rdt0=DataArrayIdType::New(),rdit0=DataArrayIdType::New();
MCUMesh m0desc = buildDescendingConnectivity(dt0, dit0, rdt0, rdit0); dt0=0; dit0=0; rdt0=0;
dsi = rdit0->deltaShiftIndex();
DAInt boundSegs = dsi->findIdsEqual(1); // boundary segs/faces of the M0 mesh
DAInt notDup = 0;
if (getMeshDimension() == 3)
{
- DAInt dnu1=DataArrayInt::New(), dnu2=DataArrayInt::New(), dnu3=DataArrayInt::New(), dnu4=DataArrayInt::New();
+ DAInt dnu1=DataArrayIdType::New(), dnu2=DataArrayIdType::New(), dnu3=DataArrayIdType::New(), dnu4=DataArrayIdType::New();
MCUMesh m0descSkinDesc = m0descSkin->buildDescendingConnectivity(dnu1, dnu2, dnu3, dnu4);
dnu1=0;dnu2=0;dnu3=0;dnu4=0;
- DataArrayInt * corresp=0;
+ DataArrayIdType * corresp=0;
meshM2->areCellsIncludedIn(m0descSkinDesc,2,corresp);
DAInt validIds = corresp->findIdsInRange(0, meshM2->getNumberOfCells());
corresp->decrRef();
//
MCUMesh m0Part2=static_cast<MEDCouplingUMesh *>(buildPartOfMySelf(cellsAroundGroup->begin(),cellsAroundGroup->end(),true));
- int nCells2 = m0Part2->getNumberOfCells();
- DAInt desc00=DataArrayInt::New(),descI00=DataArrayInt::New(),revDesc00=DataArrayInt::New(),revDescI00=DataArrayInt::New();
+ mcIdType nCells2 = m0Part2->getNumberOfCells();
+ DAInt desc00=DataArrayIdType::New(),descI00=DataArrayIdType::New(),revDesc00=DataArrayIdType::New(),revDescI00=DataArrayIdType::New();
MCUMesh m01=m0Part2->buildDescendingConnectivity(desc00,descI00,revDesc00,revDescI00);
// Neighbor information of the mesh without considering the crack (serves to count how many connex pieces it is made of)
- DataArrayInt *tmp00=0,*tmp11=0;
+ DataArrayIdType *tmp00=0,*tmp11=0;
MEDCouplingUMesh::ComputeNeighborsOfCellsAdv(desc00,descI00,revDesc00,revDescI00, tmp00, tmp11);
DAInt neighInit00(tmp00);
DAInt neighIInit00(tmp11);
// Neighbor information of the mesh WITH the crack (some neighbors are removed):
- DataArrayInt *idsTmp=0;
+ DataArrayIdType *idsTmp=0;
m01->areCellsIncludedIn(&otherDimM1OnSameCoords,2,idsTmp);
DAInt ids(idsTmp);
// In the neighbor information remove the connection between high dimension cells and its low level constituents which are part
// of the frontier given in parameter (i.e. the cells of low dimension from the group delimiting the crack):
- MEDCouplingUMesh::RemoveIdsFromIndexedArrays(ids->begin(),ids->end(),desc00,descI00);
- DataArrayInt *tmp0=0,*tmp1=0;
+ DataArrayIdType::RemoveIdsFromIndexedArrays(ids->begin(),ids->end(),desc00,descI00);
+ DataArrayIdType *tmp0=0,*tmp1=0;
// Compute the neighbor of each cell in m0Part2, taking into account the broken link above. Two
// cells on either side of the crack (defined by the mesh of low dimension) are not neighbor anymore.
ComputeNeighborsOfCellsAdv(desc00,descI00,revDesc00,revDescI00,tmp0,tmp1);
DAInt neighI00(tmp1);
// For each initial connex part of the sub-mesh (or said differently for each independent crack):
- int seed = 0, nIter = 0;
- int nIterMax = nCells2+1; // Safety net for the loop
- DAInt hitCells = DataArrayInt::New(); hitCells->alloc(nCells2);
+ mcIdType seed = 0, nIter = 0;
+ mcIdType nIterMax = nCells2+1; // Safety net for the loop
+ DAInt hitCells = DataArrayIdType::New(); hitCells->alloc(nCells2);
hitCells->fillWithValue(-1);
- DAInt cellsToModifyConn0_torenum = DataArrayInt::New();
+ DAInt cellsToModifyConn0_torenum = DataArrayIdType::New();
cellsToModifyConn0_torenum->alloc(0,1);
while (nIter < nIterMax)
{
if (!t->getNumberOfTuples())
break;
// Connex zone without the crack (to compute the next seed really)
- int dnu;
+ mcIdType dnu;
DAInt connexCheck = MEDCouplingUMesh::ComputeSpreadZoneGraduallyFromSeed(&seed, &seed+1, neighInit00,neighIInit00, -1, dnu);
- std::size_t cnt(0);
- for (int * ptr = connexCheck->getPointer(); cnt < connexCheck->getNumberOfTuples(); ptr++, cnt++)
+ mcIdType cnt(0);
+ for (mcIdType * ptr = connexCheck->getPointer(); cnt < connexCheck->getNumberOfTuples(); ptr++, cnt++)
hitCells->setIJ(*ptr,0,1);
// Connex zone WITH the crack (to identify cells lying on either part of the crack)
DAInt spreadZone = MEDCouplingUMesh::ComputeSpreadZoneGraduallyFromSeed(&seed, &seed+1, neigh00,neighI00, -1, dnu);
- cellsToModifyConn0_torenum = DataArrayInt::Aggregate(cellsToModifyConn0_torenum, spreadZone, 0);
+ cellsToModifyConn0_torenum = DataArrayIdType::Aggregate(cellsToModifyConn0_torenum, spreadZone, 0);
// Compute next seed, i.e. a cell in another connex part, which was not covered by the previous iterations
DAInt comple = cellsToModifyConn0_torenum->buildComplement(nCells2);
DAInt nonHitCells = hitCells->findIdsEqual(-1);
/*!
* This method operates a modification of the connectivity and coords in \b this.
- * Every time that a node id in [ \b nodeIdsToDuplicateBg, \b nodeIdsToDuplicateEnd ) will append in nodal connectivity of \b this
+ * Every time that a node id in [ \b nodeIdsToDuplicateBg, \b nodeIdsToDuplicateEnd ) will append in nodal connectivity of \b this
* its ids will be modified to id this->getNumberOfNodes()+std::distance(nodeIdsToDuplicateBg,std::find(nodeIdsToDuplicateBg,nodeIdsToDuplicateEnd,id)).
* More explicitly the renumber array in nodes is not explicitly given in old2new to avoid to build a big array of renumbering whereas typically few node ids needs to be
* renumbered. The node id nodeIdsToDuplicateBg[0] will have id this->getNumberOfNodes()+0, node id nodeIdsToDuplicateBg[1] will have id this->getNumberOfNodes()+1,
* node id nodeIdsToDuplicateBg[2] will have id this->getNumberOfNodes()+2...
- *
+ *
* As a consequence nodal connectivity array length will remain unchanged by this method, and nodal connectivity index array will remain unchanged by this method.
- *
+ *
* \param [in] nodeIdsToDuplicateBg begin of node ids (included) to be duplicated in connectivity only
* \param [in] nodeIdsToDuplicateEnd end of node ids (excluded) to be duplicated in connectivity only
*/
-void MEDCouplingUMesh::duplicateNodes(const int *nodeIdsToDuplicateBg, const int *nodeIdsToDuplicateEnd)
+void MEDCouplingUMesh::duplicateNodes(const mcIdType *nodeIdsToDuplicateBg, const mcIdType *nodeIdsToDuplicateEnd)
{
- int nbOfNodes=getNumberOfNodes();
+ mcIdType nbOfNodes=getNumberOfNodes();
duplicateNodesInCoords(nodeIdsToDuplicateBg,nodeIdsToDuplicateEnd);
duplicateNodesInConn(nodeIdsToDuplicateBg,nodeIdsToDuplicateEnd,nbOfNodes);
}
*
* \sa renumberNodesInConn
*/
-void MEDCouplingUMesh::renumberNodesWithOffsetInConn(int offset)
+void MEDCouplingUMesh::renumberNodesWithOffsetInConn(mcIdType offset)
{
checkConnectivityFullyDefined();
- int *conn(getNodalConnectivity()->getPointer());
- const int *connIndex(getNodalConnectivityIndex()->getConstPointer());
- int nbOfCells(getNumberOfCells());
- for(int i=0;i<nbOfCells;i++)
- for(int iconn=connIndex[i]+1;iconn!=connIndex[i+1];iconn++)
+ mcIdType *conn(getNodalConnectivity()->getPointer());
+ const mcIdType *connIndex(getNodalConnectivityIndex()->getConstPointer());
+ mcIdType nbOfCells=getNumberOfCells();
+ for(mcIdType i=0;i<nbOfCells;i++)
+ for(mcIdType iconn=connIndex[i]+1;iconn!=connIndex[i+1];iconn++)
{
- int& node=conn[iconn];
+ mcIdType& node=conn[iconn];
if(node>=0)//avoid polyhedron separator
{
node+=offset;
}
/*!
- * Same than renumberNodesInConn(const int *) except that here the format of old-to-new traducer is using map instead
+ * Same than renumberNodesInConn(const mcIdType *) except that here the format of old-to-new traducer is using map instead
* of array. This method is dedicated for renumbering from a big set of nodes the a tiny set of nodes which is the case during extraction
* of a big mesh.
*/
-void MEDCouplingUMesh::renumberNodesInConn(const INTERP_KERNEL::HashMap<int,int>& newNodeNumbersO2N)
+void MEDCouplingUMesh::renumberNodesInConn(const INTERP_KERNEL::HashMap<mcIdType,mcIdType>& newNodeNumbersO2N)
{
- this->renumberNodesInConnT< INTERP_KERNEL::HashMap<int,int> >(newNodeNumbersO2N);
+ this->renumberNodesInConnT< INTERP_KERNEL::HashMap<mcIdType,mcIdType> >(newNodeNumbersO2N);
}
/*!
- * Same than renumberNodesInConn(const int *) except that here the format of old-to-new traducer is using map instead
+ * Same than renumberNodesInConn(const mcIdType *) except that here the format of old-to-new traducer is using map instead
* of array. This method is dedicated for renumbering from a big set of nodes the a tiny set of nodes which is the case during extraction
* of a big mesh.
*/
-void MEDCouplingUMesh::renumberNodesInConn(const std::map<int,int>& newNodeNumbersO2N)
+void MEDCouplingUMesh::renumberNodesInConn(const std::map<mcIdType,mcIdType>& newNodeNumbersO2N)
{
- this->renumberNodesInConnT< std::map<int,int> >(newNodeNumbersO2N);
+ this->renumberNodesInConnT< std::map<mcIdType,mcIdType> >(newNodeNumbersO2N);
}
/*!
* This method is a generalization of shiftNodeNumbersInConn().
* \warning This method performs no check of validity of new ids. **Use it with care !**
* \param [in] newNodeNumbersO2N - a permutation array, of length \a
- * this->getNumberOfNodes(), in "Old to New" mode.
+ * this->getNumberOfNodes(), in "Old to New" mode.
* See \ref numbering for more info on renumbering modes.
* \throw If the nodal connectivity of cells is not defined.
*
* \ref py_mcumesh_renumberNodesInConn "Here is a Python example".
* \endif
*/
-void MEDCouplingUMesh::renumberNodesInConn(const int *newNodeNumbersO2N)
+void MEDCouplingUMesh::renumberNodesInConn(const mcIdType *newNodeNumbersO2N)
{
checkConnectivityFullyDefined();
- int *conn=getNodalConnectivity()->getPointer();
- const int *connIndex=getNodalConnectivityIndex()->getConstPointer();
- int nbOfCells(getNumberOfCells());
- for(int i=0;i<nbOfCells;i++)
- for(int iconn=connIndex[i]+1;iconn!=connIndex[i+1];iconn++)
+ mcIdType *conn=getNodalConnectivity()->getPointer();
+ const mcIdType *connIndex=getNodalConnectivityIndex()->getConstPointer();
+ mcIdType nbOfCells=getNumberOfCells();
+ for(mcIdType i=0;i<nbOfCells;i++)
+ for(mcIdType iconn=connIndex[i]+1;iconn!=connIndex[i+1];iconn++)
{
- int& node=conn[iconn];
+ mcIdType& node=conn[iconn];
if(node>=0)//avoid polyhedron separator
{
node=newNodeNumbersO2N[node];
* This method renumbers nodes \b in \b connectivity \b only \b without \b any \b reference \b to \b coords.
* This method performs no check on the fact that new coordinate ids are valid. \b Use \b it \b with \b care !
* This method is an specialization of \ref MEDCoupling::MEDCouplingUMesh::renumberNodesInConn "renumberNodesInConn method".
- *
+ *
* \param [in] delta specifies the shift size applied to nodeId in nodal connectivity in \b this.
*/
-void MEDCouplingUMesh::shiftNodeNumbersInConn(int delta)
+void MEDCouplingUMesh::shiftNodeNumbersInConn(mcIdType delta)
{
checkConnectivityFullyDefined();
- int *conn=getNodalConnectivity()->getPointer();
- const int *connIndex=getNodalConnectivityIndex()->getConstPointer();
- int nbOfCells=getNumberOfCells();
- for(int i=0;i<nbOfCells;i++)
- for(int iconn=connIndex[i]+1;iconn!=connIndex[i+1];iconn++)
+ mcIdType *conn=getNodalConnectivity()->getPointer();
+ const mcIdType *connIndex=getNodalConnectivityIndex()->getConstPointer();
+ mcIdType nbOfCells=getNumberOfCells();
+ for(mcIdType i=0;i<nbOfCells;i++)
+ for(mcIdType iconn=connIndex[i]+1;iconn!=connIndex[i+1];iconn++)
{
- int& node=conn[iconn];
+ mcIdType& node=conn[iconn];
if(node>=0)//avoid polyhedron separator
{
node+=delta;
/*!
* This method operates a modification of the connectivity in \b this.
* Coordinates are \b NOT considered here and will remain unchanged by this method. this->_coords can ever been null for the needs of this method.
- * Every time that a node id in [ \b nodeIdsToDuplicateBg, \b nodeIdsToDuplicateEnd ) will append in nodal connectivity of \b this
+ * Every time that a node id in [ \b nodeIdsToDuplicateBg, \b nodeIdsToDuplicateEnd ) will append in nodal connectivity of \b this
* its ids will be modified to id offset+std::distance(nodeIdsToDuplicateBg,std::find(nodeIdsToDuplicateBg,nodeIdsToDuplicateEnd,id)).
* More explicitly the renumber array in nodes is not explicitly given in old2new to avoid to build a big array of renumbering whereas typically few node ids needs to be
* renumbered. The node id nodeIdsToDuplicateBg[0] will have id offset+0, node id nodeIdsToDuplicateBg[1] will have id offset+1,
* node id nodeIdsToDuplicateBg[2] will have id offset+2...
- *
+ *
* As a consequence nodal connectivity array length will remain unchanged by this method, and nodal connectivity index array will remain unchanged by this method.
* As an another consequense after the call of this method \b this can be transiently non cohrent.
- *
+ *
* \param [in] nodeIdsToDuplicateBg begin of node ids (included) to be duplicated in connectivity only
* \param [in] nodeIdsToDuplicateEnd end of node ids (excluded) to be duplicated in connectivity only
- * \param [in] offset the offset applied to all node ids in connectivity that are in [ \a nodeIdsToDuplicateBg, \a nodeIdsToDuplicateEnd ).
+ * \param [in] offset the offset applied to all node ids in connectivity that are in [ \a nodeIdsToDuplicateBg, \a nodeIdsToDuplicateEnd ).
*/
-void MEDCouplingUMesh::duplicateNodesInConn(const int *nodeIdsToDuplicateBg, const int *nodeIdsToDuplicateEnd, int offset)
+void MEDCouplingUMesh::duplicateNodesInConn(const mcIdType *nodeIdsToDuplicateBg, const mcIdType *nodeIdsToDuplicateEnd, mcIdType offset)
{
checkConnectivityFullyDefined();
- std::map<int,int> m;
- int val=offset;
- for(const int *work=nodeIdsToDuplicateBg;work!=nodeIdsToDuplicateEnd;work++,val++)
+ std::map<mcIdType,mcIdType> m;
+ mcIdType val=offset;
+ for(const mcIdType *work=nodeIdsToDuplicateBg;work!=nodeIdsToDuplicateEnd;work++,val++)
m[*work]=val;
- int *conn=getNodalConnectivity()->getPointer();
- const int *connIndex=getNodalConnectivityIndex()->getConstPointer();
- int nbOfCells=getNumberOfCells();
- for(int i=0;i<nbOfCells;i++)
- for(int iconn=connIndex[i]+1;iconn!=connIndex[i+1];iconn++)
+ mcIdType *conn=getNodalConnectivity()->getPointer();
+ const mcIdType *connIndex=getNodalConnectivityIndex()->getConstPointer();
+ mcIdType nbOfCells=getNumberOfCells();
+ for(mcIdType i=0;i<nbOfCells;i++)
+ for(mcIdType iconn=connIndex[i]+1;iconn!=connIndex[i+1];iconn++)
{
- int& node=conn[iconn];
+ mcIdType& node=conn[iconn];
if(node>=0)//avoid polyhedron separator
{
- std::map<int,int>::iterator it=m.find(node);
+ std::map<mcIdType,mcIdType>::iterator it=m.find(node);
if(it!=m.end())
node=(*it).second;
}
* If 'check' equals false the method will not check the content of [ \a old2NewBg ; \a old2NewEnd ).
* To avoid any throw of SIGSEGV when 'check' equals false, the elements in [ \a old2NewBg ; \a old2NewEnd ) should be unique and
* should be contained in[0;this->getNumberOfCells()).
- *
+ *
* \param [in] old2NewBg is expected to be a dynamically allocated pointer of size at least equal to this->getNumberOfCells()
* \param check
*/
-void MEDCouplingUMesh::renumberCells(const int *old2NewBg, bool check)
+void MEDCouplingUMesh::renumberCells(const mcIdType *old2NewBg, bool check)
{
checkConnectivityFullyDefined();
- int nbCells=getNumberOfCells();
- const int *array=old2NewBg;
+ mcIdType nbCells=getNumberOfCells();
+ const mcIdType *array=old2NewBg;
if(check)
- array=DataArrayInt::CheckAndPreparePermutation(old2NewBg,old2NewBg+nbCells);
+ array=DataArrayIdType::CheckAndPreparePermutation(old2NewBg,old2NewBg+nbCells);
//
- const int *conn=_nodal_connec->getConstPointer();
- const int *connI=_nodal_connec_index->getConstPointer();
- MCAuto<DataArrayInt> o2n=DataArrayInt::New(); o2n->useArray(array,false,C_DEALLOC,nbCells,1);
- MCAuto<DataArrayInt> n2o=o2n->invertArrayO2N2N2O(nbCells);
- const int *n2oPtr=n2o->begin();
- MCAuto<DataArrayInt> newConn=DataArrayInt::New();
+ const mcIdType *conn=_nodal_connec->getConstPointer();
+ const mcIdType *connI=_nodal_connec_index->getConstPointer();
+ MCAuto<DataArrayIdType> o2n=DataArrayIdType::New(); o2n->useArray(array,false,DeallocType::C_DEALLOC,nbCells,1);
+ MCAuto<DataArrayIdType> n2o=o2n->invertArrayO2N2N2O(nbCells);
+ const mcIdType *n2oPtr=n2o->begin();
+ MCAuto<DataArrayIdType> newConn=DataArrayIdType::New();
newConn->alloc(_nodal_connec->getNumberOfTuples(),_nodal_connec->getNumberOfComponents());
newConn->copyStringInfoFrom(*_nodal_connec);
- MCAuto<DataArrayInt> newConnI=DataArrayInt::New();
+ MCAuto<DataArrayIdType> newConnI=DataArrayIdType::New();
newConnI->alloc(_nodal_connec_index->getNumberOfTuples(),_nodal_connec_index->getNumberOfComponents());
newConnI->copyStringInfoFrom(*_nodal_connec_index);
//
- int *newC=newConn->getPointer();
- int *newCI=newConnI->getPointer();
- int loc=0;
+ mcIdType *newC=newConn->getPointer();
+ mcIdType *newCI=newConnI->getPointer();
+ mcIdType loc=0;
newCI[0]=loc;
- for(int i=0;i<nbCells;i++)
+ for(mcIdType i=0;i<nbCells;i++)
{
- int pos=n2oPtr[i];
- int nbOfElts=connI[pos+1]-connI[pos];
+ mcIdType pos=n2oPtr[i];
+ mcIdType nbOfElts=connI[pos+1]-connI[pos];
newC=std::copy(conn+connI[pos],conn+connI[pos+1],newC);
loc+=nbOfElts;
newCI[i+1]=loc;
//
setConnectivity(newConn,newConnI);
if(check)
- free(const_cast<int *>(array));
+ free(const_cast<mcIdType *>(array));
}
/*!
* Finds cells whose bounding boxes intersect a given bounding box.
* \param [in] bbox - an array defining the bounding box via coordinates of its
* extremum points in "no interlace" mode, i.e. xMin, xMax, yMin, yMax, zMin,
- * zMax (if in 3D).
+ * zMax (if in 3D).
* \param [in] eps - a factor used to increase size of the bounding box of cell
* before comparing it with \a bbox. This factor is multiplied by the maximal
* extent of the bounding box of cell to produce an addition to this bounding box.
- * \return DataArrayInt * - a new instance of DataArrayInt holding ids for found
+ * \return DataArrayIdType * - a new instance of DataArrayIdType holding ids for found
* cells. The caller is to delete this array using decrRef() as it is no more
- * needed.
+ * needed.
* \throw If the coordinates array is not set.
* \throw If the nodal connectivity of cells is not defined.
*
* \ref py_mcumesh_getCellsInBoundingBox "Here is a Python example".
* \endif
*/
-DataArrayInt *MEDCouplingUMesh::getCellsInBoundingBox(const double *bbox, double eps) const
+DataArrayIdType *MEDCouplingUMesh::getCellsInBoundingBox(const double *bbox, double eps) const
{
- MCAuto<DataArrayInt> elems=DataArrayInt::New(); elems->alloc(0,1);
+ MCAuto<DataArrayIdType> elems=DataArrayIdType::New(); elems->alloc(0,1);
if(getMeshDimension()==-1)
{
elems->pushBackSilent(0);
}
int dim=getSpaceDimension();
INTERP_KERNEL::AutoPtr<double> elem_bb=new double[2*dim];
- const int* conn = getNodalConnectivity()->getConstPointer();
- const int* conn_index= getNodalConnectivityIndex()->getConstPointer();
+ const mcIdType* conn = getNodalConnectivity()->getConstPointer();
+ const mcIdType* conn_index= getNodalConnectivityIndex()->getConstPointer();
const double* coords = getCoords()->getConstPointer();
- int nbOfCells=getNumberOfCells();
- for ( int ielem=0; ielem<nbOfCells;ielem++ )
+ mcIdType nbOfCells=getNumberOfCells();
+ for ( mcIdType ielem=0; ielem<nbOfCells;ielem++ )
{
for (int i=0; i<dim; i++)
{
elem_bb[i*2+1]=-std::numeric_limits<double>::max();
}
- for (int inode=conn_index[ielem]+1; inode<conn_index[ielem+1]; inode++)//+1 due to offset of cell type.
+ for (mcIdType inode=conn_index[ielem]+1; inode<conn_index[ielem+1]; inode++)//+1 due to offset of cell type.
{
- int node= conn[inode];
+ mcIdType node= conn[inode];
if(node>=0)//avoid polyhedron separator
{
for (int idim=0; idim<dim; idim++)
* Warning 'elems' is incremented during the call so if elems is not empty before call returned elements will be
* added in 'elems' parameter.
*/
-DataArrayInt *MEDCouplingUMesh::getCellsInBoundingBox(const INTERP_KERNEL::DirectedBoundingBox& bbox, double eps)
+DataArrayIdType *MEDCouplingUMesh::getCellsInBoundingBox(const INTERP_KERNEL::DirectedBoundingBox& bbox, double eps)
{
- MCAuto<DataArrayInt> elems=DataArrayInt::New(); elems->alloc(0,1);
+ MCAuto<DataArrayIdType> elems=DataArrayIdType::New(); elems->alloc(0,1);
if(getMeshDimension()==-1)
{
elems->pushBackSilent(0);
}
int dim=getSpaceDimension();
INTERP_KERNEL::AutoPtr<double> elem_bb=new double[2*dim];
- const int* conn = getNodalConnectivity()->getConstPointer();
- const int* conn_index= getNodalConnectivityIndex()->getConstPointer();
+ const mcIdType* conn = getNodalConnectivity()->getConstPointer();
+ const mcIdType* conn_index= getNodalConnectivityIndex()->getConstPointer();
const double* coords = getCoords()->getConstPointer();
- int nbOfCells=getNumberOfCells();
- for ( int ielem=0; ielem<nbOfCells;ielem++ )
+ mcIdType nbOfCells=getNumberOfCells();
+ for ( mcIdType ielem=0; ielem<nbOfCells;ielem++ )
{
for (int i=0; i<dim; i++)
{
elem_bb[i*2+1]=-std::numeric_limits<double>::max();
}
- for (int inode=conn_index[ielem]+1; inode<conn_index[ielem+1]; inode++)//+1 due to offset of cell type.
+ for (mcIdType inode=conn_index[ielem]+1; inode<conn_index[ielem+1]; inode++)//+1 due to offset of cell type.
{
- int node= conn[inode];
+ mcIdType node= conn[inode];
if(node>=0)//avoid polyhedron separator
{
for (int idim=0; idim<dim; idim++)
* \return INTERP_KERNEL::NormalizedCellType - enumeration item describing the cell type.
* \throw If \a cellId is invalid. Valid range is [0, \a this->getNumberOfCells() ).
*/
-INTERP_KERNEL::NormalizedCellType MEDCouplingUMesh::getTypeOfCell(std::size_t cellId) const
+INTERP_KERNEL::NormalizedCellType MEDCouplingUMesh::getTypeOfCell(mcIdType cellId) const
{
- const int *ptI(_nodal_connec_index->begin()),*pt(_nodal_connec->begin());
+ const mcIdType *ptI(_nodal_connec_index->begin()),*pt(_nodal_connec->begin());
if(cellId<_nodal_connec_index->getNbOfElems()-1)
return (INTERP_KERNEL::NormalizedCellType) pt[ptI[cellId]];
else
* \param [in] type the geometric type
* \return cell ids in this having geometric type \a type.
*/
-DataArrayInt *MEDCouplingUMesh::giveCellsWithType(INTERP_KERNEL::NormalizedCellType type) const
+DataArrayIdType *MEDCouplingUMesh::giveCellsWithType(INTERP_KERNEL::NormalizedCellType type) const
{
- MCAuto<DataArrayInt> ret=DataArrayInt::New();
+ MCAuto<DataArrayIdType> ret=DataArrayIdType::New();
ret->alloc(0,1);
checkConnectivityFullyDefined();
- int nbCells=getNumberOfCells();
+ mcIdType nbCells=getNumberOfCells();
int mdim=getMeshDimension();
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(type);
- if(mdim!=(int)cm.getDimension())
+ if(mdim!=ToIdType(cm.getDimension()))
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::giveCellsWithType : Mismatch between mesh dimension and dimension of the cell !");
- const int *ptI=_nodal_connec_index->getConstPointer();
- const int *pt=_nodal_connec->getConstPointer();
- for(int i=0;i<nbCells;i++)
+ const mcIdType *ptI=_nodal_connec_index->getConstPointer();
+ const mcIdType *pt=_nodal_connec->getConstPointer();
+ for(mcIdType i=0;i<nbCells;i++)
{
if((INTERP_KERNEL::NormalizedCellType)pt[ptI[i]]==type)
ret->pushBackSilent(i);
/*!
* Returns nb of cells having the geometric type \a type. No throw if no cells in \a this has the geometric type \a type.
*/
-std::size_t MEDCouplingUMesh::getNumberOfCellsWithType(INTERP_KERNEL::NormalizedCellType type) const
+mcIdType MEDCouplingUMesh::getNumberOfCellsWithType(INTERP_KERNEL::NormalizedCellType type) const
{
- const int *ptI(_nodal_connec_index->begin()),*pt(_nodal_connec->begin());
- std::size_t nbOfCells(getNumberOfCells()),ret(0);
- for(std::size_t i=0;i<nbOfCells;i++)
+ const mcIdType *ptI(_nodal_connec_index->begin()),*pt(_nodal_connec->begin());
+ mcIdType nbOfCells(getNumberOfCells()),ret(0);
+ for(mcIdType i=0;i<nbOfCells;i++)
if((INTERP_KERNEL::NormalizedCellType) pt[ptI[i]]==type)
ret++;
return ret;
* cleared before the appending.
* \throw If \a cellId is invalid. Valid range is [0, \a this->getNumberOfCells() ).
*/
-void MEDCouplingUMesh::getNodeIdsOfCell(std::size_t cellId, std::vector<int>& conn) const
+void MEDCouplingUMesh::getNodeIdsOfCell(mcIdType cellId, std::vector<mcIdType>& conn) const
{
- const int *ptI(_nodal_connec_index->begin()),*pt(_nodal_connec->begin());
- for(const int *w=pt+ptI[cellId]+1;w!=pt+ptI[cellId+1];w++)
+ const mcIdType *ptI(_nodal_connec_index->begin()),*pt(_nodal_connec->begin());
+ for(const mcIdType *w=pt+ptI[cellId]+1;w!=pt+ptI[cellId+1];w++)
if(*w>=0)
conn.push_back(*w);
}
* This method returns an instance with all arrays allocated (connectivity, connectivity index, coordinates)
* but with length of these arrays set to 0. It allows to define an "empty" mesh (with nor cells nor nodes but compliant with
* some algos).
- *
+ *
* This method expects that \a this has a mesh dimension set and higher or equal to 0. If not an exception will be thrown.
* This method analyzes the 3 arrays of \a this. For each the following behaviour is done : if the array is null a newly one is created
* with number of tuples set to 0, if not the array is taken as this in the returned instance.
*/
-MEDCouplingUMesh *MEDCouplingUMesh::buildSetInstanceFromThis(int spaceDim) const
+MEDCouplingUMesh *MEDCouplingUMesh::buildSetInstanceFromThis(std::size_t spaceDim) const
{
int mdim=getMeshDimension();
if(mdim<0)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::buildSetInstanceFromThis : invalid mesh dimension ! Should be >= 0 !");
MCAuto<MEDCouplingUMesh> ret=MEDCouplingUMesh::New(getName(),mdim);
- MCAuto<DataArrayInt> tmp1,tmp2;
+ MCAuto<DataArrayIdType> tmp1,tmp2;
bool needToCpyCT=true;
if(!_nodal_connec)
{
- tmp1=DataArrayInt::New(); tmp1->alloc(0,1);
+ tmp1=DataArrayIdType::New(); tmp1->alloc(0,1);
needToCpyCT=false;
}
else
}
if(!_nodal_connec_index)
{
- tmp2=DataArrayInt::New(); tmp2->alloc(1,1); tmp2->setIJ(0,0,0);
+ tmp2=DataArrayIdType::New(); tmp2->alloc(1,1); tmp2->setIJ(0,0,0);
needToCpyCT=false;
}
else
return ret.retn();
}
-int MEDCouplingUMesh::getNumberOfNodesInCell(int cellId) const
+mcIdType MEDCouplingUMesh::getNumberOfNodesInCell(mcIdType cellId) const
{
- const int *ptI=_nodal_connec_index->getConstPointer();
- const int *pt=_nodal_connec->getConstPointer();
+ const mcIdType *ptI=_nodal_connec_index->getConstPointer();
+ const mcIdType *pt=_nodal_connec->getConstPointer();
if(pt[ptI[cellId]]!=INTERP_KERNEL::NORM_POLYHED)
return ptI[cellId+1]-ptI[cellId]-1;
else
- return (int)std::count_if(pt+ptI[cellId]+1,pt+ptI[cellId+1],std::bind2nd(std::not_equal_to<int>(),-1));
+ return ToIdType(std::count_if(pt+ptI[cellId]+1,pt+ptI[cellId+1],std::bind2nd(std::not_equal_to<mcIdType>(),-1)));
}
/*!
* \param [in] begin - an array of cell ids of interest.
* \param [in] end - the end of \a begin, i.e. a pointer to its (last+1)-th element.
* \return std::set<INTERP_KERNEL::NormalizedCellType> - a set of enumeration items
- * describing the cell types.
+ * describing the cell types.
* \throw If the coordinates array is not set.
* \throw If the nodal connectivity of cells is not defined.
* \sa getAllGeoTypes()
*/
-std::set<INTERP_KERNEL::NormalizedCellType> MEDCouplingUMesh::getTypesOfPart(const int *begin, const int *end) const
+std::set<INTERP_KERNEL::NormalizedCellType> MEDCouplingUMesh::getTypesOfPart(const mcIdType *begin, const mcIdType *end) const
{
checkFullyDefined();
std::set<INTERP_KERNEL::NormalizedCellType> ret;
- const int *conn=_nodal_connec->getConstPointer();
- const int *connIndex=_nodal_connec_index->getConstPointer();
- for(const int *w=begin;w!=end;w++)
+ const mcIdType *conn=_nodal_connec->getConstPointer();
+ const mcIdType *connIndex=_nodal_connec_index->getConstPointer();
+ for(const mcIdType *w=begin;w!=end;w++)
ret.insert((INTERP_KERNEL::NormalizedCellType)conn[connIndex[*w]]);
return ret;
}
/*!
* Defines the nodal connectivity using given connectivity arrays in \ref numbering-indirect format.
* Optionally updates
- * a set of types of cells constituting \a this mesh.
+ * a set of types of cells constituting \a this mesh.
* This method is for advanced users having prepared their connectivity before. For
* more info on using this method see \ref MEDCouplingUMeshAdvBuild.
- * \param [in] conn - the nodal connectivity array.
+ * \param [in] conn - the nodal connectivity array.
* \param [in] connIndex - the nodal connectivity index array.
* \param [in] isComputingTypes - if \c true, the set of types constituting \a this
* mesh is updated.
*/
-void MEDCouplingUMesh::setConnectivity(DataArrayInt *conn, DataArrayInt *connIndex, bool isComputingTypes)
+void MEDCouplingUMesh::setConnectivity(DataArrayIdType *conn, DataArrayIdType *connIndex, bool isComputingTypes)
{
- DataArrayInt::SetArrayIn(conn,_nodal_connec);
- DataArrayInt::SetArrayIn(connIndex,_nodal_connec_index);
+ DataArrayIdType::SetArrayIn(conn,_nodal_connec);
+ DataArrayIdType::SetArrayIn(connIndex,_nodal_connec_index);
if(isComputingTypes)
computeTypes();
declareAsNew();
/*!
- * Returns a number of cells constituting \a this mesh.
- * \return int - the number of cells in \a this mesh.
+ * Returns a number of cells constituting \a this mesh.
+ * \return mcIdType - the number of cells in \a this mesh.
* \throw If the nodal connectivity of cells is not defined.
*/
-std::size_t MEDCouplingUMesh::getNumberOfCells() const
-{
+mcIdType MEDCouplingUMesh::getNumberOfCells() const
+{
if(_nodal_connec_index)
return _nodal_connec_index->getNumberOfTuples()-1;
else
* Returns a length of the nodal connectivity array.
* This method is for test reason. Normally the integer returned is not useable by
* user. For more info see \ref MEDCouplingUMeshNodalConnectivity.
- * \return int - the length of the nodal connectivity array.
+ * \return mcIdType - the length of the nodal connectivity array.
*/
-int MEDCouplingUMesh::getNodalConnectivityArrayLen() const
+mcIdType MEDCouplingUMesh::getNodalConnectivityArrayLen() const
{
return _nodal_connec->getNbOfElems();
}
/*!
* First step of serialization process. Used by ParaMEDMEM and MEDCouplingCorba to transfert data between process.
*/
-void MEDCouplingUMesh::getTinySerializationInformation(std::vector<double>& tinyInfoD, std::vector<int>& tinyInfo, std::vector<std::string>& littleStrings) const
+void MEDCouplingUMesh::getTinySerializationInformation(std::vector<double>& tinyInfoD, std::vector<mcIdType>& tinyInfo, std::vector<std::string>& littleStrings) const
{
MEDCouplingPointSet::getTinySerializationInformation(tinyInfoD,tinyInfo,littleStrings);
- tinyInfo.push_back(getMeshDimension());
+ tinyInfo.push_back(ToIdType(getMeshDimension()));
tinyInfo.push_back(getNumberOfCells());
if(_nodal_connec)
tinyInfo.push_back(getNodalConnectivityArrayLen());
/*!
* First step of unserialization process.
*/
-bool MEDCouplingUMesh::isEmptyMesh(const std::vector<int>& tinyInfo) const
+bool MEDCouplingUMesh::isEmptyMesh(const std::vector<mcIdType>& tinyInfo) const
{
return tinyInfo[6]<=0;
}
* \param a2
* \param littleStrings
*/
-void MEDCouplingUMesh::resizeForUnserialization(const std::vector<int>& tinyInfo, DataArrayInt *a1, DataArrayDouble *a2, std::vector<std::string>& littleStrings) const
+void MEDCouplingUMesh::resizeForUnserialization(const std::vector<mcIdType>& tinyInfo, DataArrayIdType *a1, DataArrayDouble *a2, std::vector<std::string>& littleStrings) const
{
MEDCouplingPointSet::resizeForUnserialization(tinyInfo,a1,a2,littleStrings);
if(tinyInfo[5]!=-1)
/*!
* Third and final step of serialization process.
*/
-void MEDCouplingUMesh::serialize(DataArrayInt *&a1, DataArrayDouble *&a2) const
+void MEDCouplingUMesh::serialize(DataArrayIdType *&a1, DataArrayDouble *&a2) const
{
MEDCouplingPointSet::serialize(a1,a2);
if(getMeshDimension()>-1)
{
- a1=DataArrayInt::New();
+ a1=DataArrayIdType::New();
a1->alloc(getNodalConnectivityArrayLen()+getNumberOfCells()+1,1);
- int *ptA1=a1->getPointer();
- const int *conn=getNodalConnectivity()->getConstPointer();
- const int *index=getNodalConnectivityIndex()->getConstPointer();
+ mcIdType *ptA1=a1->getPointer();
+ const mcIdType *conn=getNodalConnectivity()->getConstPointer();
+ const mcIdType *index=getNodalConnectivityIndex()->getConstPointer();
ptA1=std::copy(index,index+getNumberOfCells()+1,ptA1);
std::copy(conn,conn+getNodalConnectivityArrayLen(),ptA1);
}
* Second and final unserialization process.
* \param tinyInfo must be equal to the result given by getTinySerializationInformation method.
*/
-void MEDCouplingUMesh::unserialization(const std::vector<double>& tinyInfoD, const std::vector<int>& tinyInfo, const DataArrayInt *a1, DataArrayDouble *a2, const std::vector<std::string>& littleStrings)
+void MEDCouplingUMesh::unserialization(const std::vector<double>& tinyInfoD, const std::vector<mcIdType>& tinyInfo, const DataArrayIdType *a1, DataArrayDouble *a2, const std::vector<std::string>& littleStrings)
{
MEDCouplingPointSet::unserialization(tinyInfoD,tinyInfo,a1,a2,littleStrings);
- setMeshDimension(tinyInfo[5]);
+ setMeshDimension(FromIdType<int>(tinyInfo[5]));
if(tinyInfo[7]!=-1)
{
// Connectivity
- const int *recvBuffer=a1->getConstPointer();
- MCAuto<DataArrayInt> myConnecIndex=DataArrayInt::New();
+ const mcIdType *recvBuffer=a1->getConstPointer();
+ MCAuto<DataArrayIdType> myConnecIndex=DataArrayIdType::New();
myConnecIndex->alloc(tinyInfo[6]+1,1);
std::copy(recvBuffer,recvBuffer+tinyInfo[6]+1,myConnecIndex->getPointer());
- MCAuto<DataArrayInt> myConnec=DataArrayInt::New();
+ MCAuto<DataArrayIdType> myConnec=DataArrayIdType::New();
myConnec->alloc(tinyInfo[7],1);
std::copy(recvBuffer+tinyInfo[6]+1,recvBuffer+tinyInfo[6]+1+tinyInfo[7],myConnec->getPointer());
setConnectivity(myConnec, myConnecIndex);
{
std::string name="MeasureOfMesh_";
name+=getName();
- int nbelem=getNumberOfCells();
+ mcIdType nbelem=getNumberOfCells();
MCAuto<MEDCouplingFieldDouble> field=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
field->setName(name);
MCAuto<DataArrayDouble> array=DataArrayDouble::New();
field->synchronizeTimeWithMesh();
if(getMeshDimension()!=-1)
{
- int ipt;
+ mcIdType ipt;
INTERP_KERNEL::NormalizedCellType type;
int dim_space=getSpaceDimension();
const double *coords=getCoords()->getConstPointer();
- const int *connec=getNodalConnectivity()->getConstPointer();
- const int *connec_index=getNodalConnectivityIndex()->getConstPointer();
- for(int iel=0;iel<nbelem;iel++)
+ const mcIdType *connec=getNodalConnectivity()->getConstPointer();
+ const mcIdType *connec_index=getNodalConnectivityIndex()->getConstPointer();
+ for(mcIdType iel=0;iel<nbelem;iel++)
{
ipt=connec_index[iel];
type=(INTERP_KERNEL::NormalizedCellType)connec[ipt];
- area_vol[iel]=INTERP_KERNEL::computeVolSurfOfCell2<int,INTERP_KERNEL::ALL_C_MODE>(type,connec+ipt+1,connec_index[iel+1]-ipt-1,coords,dim_space);
+ area_vol[iel]=INTERP_KERNEL::computeVolSurfOfCell2<mcIdType,INTERP_KERNEL::ALL_C_MODE>(type,connec+ipt+1,connec_index[iel+1]-ipt-1,coords,dim_space);
}
if(isAbs)
std::transform(area_vol,area_vol+nbelem,area_vol,std::ptr_fun<double,double>(fabs));
* \param [in] end - the end of \a begin, i.e. a pointer to its (last+1)-th element.
* \return DataArrayDouble * - a new instance of DataArrayDouble. The caller is to
* delete this array using decrRef() as it is no more needed.
- *
+ *
* \if ENABLE_EXAMPLES
* \ref cpp_mcumesh_getPartMeasureField "Here is a C++ example".<br>
* \ref py_mcumesh_getPartMeasureField "Here is a Python example".
* \endif
* \sa getMeasureField()
*/
-DataArrayDouble *MEDCouplingUMesh::getPartMeasureField(bool isAbs, const int *begin, const int *end) const
+DataArrayDouble *MEDCouplingUMesh::getPartMeasureField(bool isAbs, const mcIdType *begin, const mcIdType *end) const
{
std::string name="PartMeasureOfMesh_";
name+=getName();
- int nbelem=(int)std::distance(begin,end);
+ std::size_t nbelem=std::distance(begin,end);
MCAuto<DataArrayDouble> array=DataArrayDouble::New();
array->setName(name);
array->alloc(nbelem,1);
double *area_vol=array->getPointer();
if(getMeshDimension()!=-1)
{
- int ipt;
+ mcIdType ipt;
INTERP_KERNEL::NormalizedCellType type;
int dim_space=getSpaceDimension();
const double *coords=getCoords()->getConstPointer();
- const int *connec=getNodalConnectivity()->getConstPointer();
- const int *connec_index=getNodalConnectivityIndex()->getConstPointer();
- for(const int *iel=begin;iel!=end;iel++)
+ const mcIdType *connec=getNodalConnectivity()->getConstPointer();
+ const mcIdType *connec_index=getNodalConnectivityIndex()->getConstPointer();
+ for(const mcIdType *iel=begin;iel!=end;iel++)
{
ipt=connec_index[*iel];
type=(INTERP_KERNEL::NormalizedCellType)connec[ipt];
- *area_vol++=INTERP_KERNEL::computeVolSurfOfCell2<int,INTERP_KERNEL::ALL_C_MODE>(type,connec+ipt+1,connec_index[*iel+1]-ipt-1,coords,dim_space);
+ *area_vol++=INTERP_KERNEL::computeVolSurfOfCell2<mcIdType,INTERP_KERNEL::ALL_C_MODE>(type,connec+ipt+1,connec_index[*iel+1]-ipt-1,coords,dim_space);
}
if(isAbs)
std::transform(array->getPointer(),area_vol,array->getPointer(),std::ptr_fun<double,double>(fabs));
MCAuto<MEDCouplingFieldDouble> tmp=getMeasureField(isAbs);
std::string name="MeasureOnNodeOfMesh_";
name+=getName();
- int nbNodes=getNumberOfNodes();
+ mcIdType nbNodes=getNumberOfNodes();
+ MCAuto<DataArrayDouble> nnpc;
+ {
+ MCAuto<DataArrayIdType> tmp(computeNbOfNodesPerCell());
+ nnpc=tmp->convertToDblArr();
+ }
+ std::for_each(nnpc->rwBegin(),nnpc->rwEnd(),[](double& v) { v=1./v; });
+ const double *nnpcPtr(nnpc->begin());
MCAuto<MEDCouplingFieldDouble> ret=MEDCouplingFieldDouble::New(ON_NODES);
- double cst=1./((double)getMeshDimension()+1.);
MCAuto<DataArrayDouble> array=DataArrayDouble::New();
array->alloc(nbNodes,1);
double *valsToFill=array->getPointer();
std::fill(valsToFill,valsToFill+nbNodes,0.);
const double *values=tmp->getArray()->getConstPointer();
- MCAuto<DataArrayInt> da=DataArrayInt::New();
- MCAuto<DataArrayInt> daInd=DataArrayInt::New();
+ MCAuto<DataArrayIdType> da=DataArrayIdType::New();
+ MCAuto<DataArrayIdType> daInd=DataArrayIdType::New();
getReverseNodalConnectivity(da,daInd);
- const int *daPtr=da->getConstPointer();
- const int *daIPtr=daInd->getConstPointer();
- for(int i=0;i<nbNodes;i++)
- for(const int *cell=daPtr+daIPtr[i];cell!=daPtr+daIPtr[i+1];cell++)
- valsToFill[i]+=cst*values[*cell];
+ const mcIdType *daPtr=da->getConstPointer();
+ const mcIdType *daIPtr=daInd->getConstPointer();
+ for(mcIdType i=0;i<nbNodes;i++)
+ for(const mcIdType *cell=daPtr+daIPtr[i];cell!=daPtr+daIPtr[i+1];cell++)
+ valsToFill[i]+=nnpcPtr[*cell]*values[*cell];
ret->setMesh(this);
ret->setArray(array);
return ret.retn();
* mesh. The returned normal vectors to each cell have a norm2 equal to 1.
* The computed vectors have <em> this->getMeshDimension()+1 </em> components
* and are normalized.
- * <br> \a this can be either
- * - a 2D mesh in 2D or 3D space or
+ * <br> \a this can be either
+ * - a 2D mesh in 2D or 3D space or
* - an 1D mesh in 2D space.
- *
+ *
* \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble on
* cells and one time. The caller is to delete this field using decrRef() as
* it is no more needed.
throw INTERP_KERNEL::Exception("Expected a umesh with ( meshDim == 2 spaceDim == 2 or 3 ) or ( meshDim == 1 spaceDim == 2 ) !");
MCAuto<MEDCouplingFieldDouble> ret=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
MCAuto<DataArrayDouble> array=DataArrayDouble::New();
- int nbOfCells=getNumberOfCells();
+ mcIdType nbOfCells=getNumberOfCells();
int nbComp=getMeshDimension()+1;
array->alloc(nbOfCells,nbComp);
double *vals=array->getPointer();
- const int *connI=_nodal_connec_index->getConstPointer();
- const int *conn=_nodal_connec->getConstPointer();
+ const mcIdType *connI=_nodal_connec_index->getConstPointer();
+ const mcIdType *conn=_nodal_connec->getConstPointer();
const double *coords=_coords->getConstPointer();
if(getMeshDimension()==2)
{
{
MCAuto<DataArrayDouble> loc=computeCellCenterOfMass();
const double *locPtr=loc->getConstPointer();
- for(int i=0;i<nbOfCells;i++,vals+=3)
+ for(mcIdType i=0;i<nbOfCells;i++,vals+=3)
{
- int offset=connI[i];
+ mcIdType offset=connI[i];
INTERP_KERNEL::crossprod<3>(locPtr+3*i,coords+3*conn[offset+1],coords+3*conn[offset+2],vals);
double n=INTERP_KERNEL::norm<3>(vals);
std::transform(vals,vals+3,vals,std::bind2nd(std::multiplies<double>(),1./n));
{
MCAuto<MEDCouplingFieldDouble> isAbs=getMeasureField(false);
const double *isAbsPtr=isAbs->getArray()->begin();
- for(int i=0;i<nbOfCells;i++,isAbsPtr++)
+ for(mcIdType i=0;i<nbOfCells;i++,isAbsPtr++)
{ vals[3*i]=0.; vals[3*i+1]=0.; vals[3*i+2]=*isAbsPtr>0.?1.:-1.; }
}
}
else//meshdimension==1
{
double tmp[2];
- for(int i=0;i<nbOfCells;i++)
+ for(mcIdType i=0;i<nbOfCells;i++)
{
- int offset=connI[i];
+ mcIdType offset=connI[i];
std::transform(coords+2*conn[offset+2],coords+2*conn[offset+2]+2,coords+2*conn[offset+1],tmp,std::minus<double>());
double n=INTERP_KERNEL::norm<2>(tmp);
std::transform(tmp,tmp+2,tmp,std::bind2nd(std::multiplies<double>(),1./n));
* Returns a new MEDCouplingFieldDouble holding normal vectors to specified cells of
* \a this mesh. The computed vectors have <em> this->getMeshDimension()+1 </em> components
* and are normalized.
- * <br> \a this can be either
- * - a 2D mesh in 2D or 3D space or
+ * <br> \a this can be either
+ * - a 2D mesh in 2D or 3D space or
* - an 1D mesh in 2D space.
- *
+ *
* This method avoids building explicitly a part of \a this mesh to perform the work.
* \param [in] begin - an array of cell ids of interest.
* \param [in] end - the end of \a begin, i.e. a pointer to its (last+1)-th element.
* \ref py_mcumesh_buildPartOrthogonalField "Here is a Python example".
* \endif
*/
-MEDCouplingFieldDouble *MEDCouplingUMesh::buildPartOrthogonalField(const int *begin, const int *end) const
+MEDCouplingFieldDouble *MEDCouplingUMesh::buildPartOrthogonalField(const mcIdType *begin, const mcIdType *end) const
{
if((getMeshDimension()!=2) && (getMeshDimension()!=1 || getSpaceDimension()!=2))
throw INTERP_KERNEL::Exception("Expected a umesh with ( meshDim == 2 spaceDim == 2 or 3 ) or ( meshDim == 1 spaceDim == 2 ) !");
MCAuto<DataArrayDouble> array=DataArrayDouble::New();
std::size_t nbelems=std::distance(begin,end);
int nbComp=getMeshDimension()+1;
- array->alloc((int)nbelems,nbComp);
+ array->alloc(nbelems,nbComp);
double *vals=array->getPointer();
- const int *connI=_nodal_connec_index->getConstPointer();
- const int *conn=_nodal_connec->getConstPointer();
+ const mcIdType *connI=_nodal_connec_index->getConstPointer();
+ const mcIdType *conn=_nodal_connec->getConstPointer();
const double *coords=_coords->getConstPointer();
if(getMeshDimension()==2)
{
{
MCAuto<DataArrayDouble> loc=getPartBarycenterAndOwner(begin,end);
const double *locPtr=loc->getConstPointer();
- for(const int *i=begin;i!=end;i++,vals+=3,locPtr+=3)
+ for(const mcIdType *i=begin;i!=end;i++,vals+=3,locPtr+=3)
{
- int offset=connI[*i];
+ mcIdType offset=connI[*i];
INTERP_KERNEL::crossprod<3>(locPtr,coords+3*conn[offset+1],coords+3*conn[offset+2],vals);
double n=INTERP_KERNEL::norm<3>(vals);
std::transform(vals,vals+3,vals,std::bind2nd(std::multiplies<double>(),1./n));
else//meshdimension==1
{
double tmp[2];
- for(const int *i=begin;i!=end;i++)
+ for(const mcIdType *i=begin;i!=end;i++)
{
- int offset=connI[*i];
+ mcIdType offset=connI[*i];
std::transform(coords+2*conn[offset+2],coords+2*conn[offset+2]+2,coords+2*conn[offset+1],tmp,std::minus<double>());
double n=INTERP_KERNEL::norm<2>(tmp);
std::transform(tmp,tmp+2,tmp,std::bind2nd(std::multiplies<double>(),1./n));
throw INTERP_KERNEL::Exception("Expected a umesh with only NORM_SEG2 type of elements for buildDirectionVectorField !");
MCAuto<MEDCouplingFieldDouble> ret=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
MCAuto<DataArrayDouble> array=DataArrayDouble::New();
- int nbOfCells=getNumberOfCells();
+ mcIdType nbOfCells=getNumberOfCells();
int spaceDim=getSpaceDimension();
array->alloc(nbOfCells,spaceDim);
double *pt=array->getPointer();
const double *coo=getCoords()->getConstPointer();
- std::vector<int> conn;
+ std::vector<mcIdType> conn;
conn.reserve(2);
- for(int i=0;i<nbOfCells;i++)
+ for(mcIdType i=0;i<nbOfCells;i++)
{
conn.resize(0);
getNodeIdsOfCell(i,conn);
/*!
* Creates a 2D mesh by cutting \a this 3D mesh with a plane. In addition to the mesh,
- * returns a new DataArrayInt, of length equal to the number of 2D cells in the result
+ * returns a new DataArrayIdType, of length equal to the number of 2D cells in the result
* mesh, holding, for each cell in the result mesh, an id of a 3D cell it comes
* from. If a result face is shared by two 3D cells, then the face in included twice in
* the result mesh.
* \param [in] vec - 3 components of a vector normal to the plane. Vector magnitude
* must be greater than 1e-6.
* \param [in] eps - half-thickness of the plane.
- * \param [out] cellIds - a new instance of DataArrayInt holding ids of 3D cells
+ * \param [out] cellIds - a new instance of DataArrayIdType holding ids of 3D cells
* producing correspondent 2D cells. The caller is to delete this array
* using decrRef() as it is no more needed.
* \return MEDCouplingUMesh * - a new instance of MEDCouplingUMesh. This mesh does
* not share the node coordinates array with \a this mesh. The caller is to
- * delete this mesh using decrRef() as it is no more needed.
+ * delete this mesh using decrRef() as it is no more needed.
* \throw If the coordinates array is not set.
* \throw If the nodal connectivity of cells is not defined.
* \throw If \a this->getMeshDimension() != 3 or \a this->getSpaceDimension() != 3.
* \throw If the plane does not intersect any 3D cell of \a this mesh.
* \throw If \a this includes quadratic cells.
*/
-MEDCouplingUMesh *MEDCouplingUMesh::buildSlice3D(const double *origin, const double *vec, double eps, DataArrayInt *&cellIds) const
+MEDCouplingUMesh *MEDCouplingUMesh::buildSlice3D(const double *origin, const double *vec, double eps, DataArrayIdType *&cellIds) const
{
checkFullyDefined();
if(getMeshDimension()!=3 || getSpaceDimension()!=3)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::buildSlice3D works on umeshes with meshdim equal to 3 and spaceDim equal to 3 too!");
- MCAuto<DataArrayInt> candidates=getCellIdsCrossingPlane(origin,vec,eps);
+ MCAuto<DataArrayIdType> candidates=getCellIdsCrossingPlane(origin,vec,eps);
if(candidates->empty())
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::buildSlice3D : No 3D cells in this intercepts the specified plane considering bounding boxes !");
- std::vector<int> nodes;
- DataArrayInt *cellIds1D=0;
+ std::vector<mcIdType> nodes;
+ DataArrayIdType *cellIds1D=0;
MCAuto<MEDCouplingUMesh> subMesh=static_cast<MEDCouplingUMesh*>(buildPartOfMySelf(candidates->begin(),candidates->end(),false));
subMesh->findNodesOnPlane(origin,vec,eps,nodes);
- MCAuto<DataArrayInt> desc1=DataArrayInt::New(),desc2=DataArrayInt::New();
- MCAuto<DataArrayInt> descIndx1=DataArrayInt::New(),descIndx2=DataArrayInt::New();
- MCAuto<DataArrayInt> revDesc1=DataArrayInt::New(),revDesc2=DataArrayInt::New();
- MCAuto<DataArrayInt> revDescIndx1=DataArrayInt::New(),revDescIndx2=DataArrayInt::New();
+ MCAuto<DataArrayIdType> desc1=DataArrayIdType::New(),desc2=DataArrayIdType::New();
+ MCAuto<DataArrayIdType> descIndx1=DataArrayIdType::New(),descIndx2=DataArrayIdType::New();
+ MCAuto<DataArrayIdType> revDesc1=DataArrayIdType::New(),revDesc2=DataArrayIdType::New();
+ MCAuto<DataArrayIdType> revDescIndx1=DataArrayIdType::New(),revDescIndx2=DataArrayIdType::New();
MCAuto<MEDCouplingUMesh> mDesc2=subMesh->buildDescendingConnectivity(desc2,descIndx2,revDesc2,revDescIndx2);//meshDim==2 spaceDim==3
revDesc2=0; revDescIndx2=0;
MCAuto<MEDCouplingUMesh> mDesc1=mDesc2->buildDescendingConnectivity(desc1,descIndx1,revDesc1,revDescIndx1);//meshDim==1 spaceDim==3
revDesc1=0; revDescIndx1=0;
mDesc1->fillCellIdsToKeepFromNodeIds(&nodes[0],&nodes[0]+nodes.size(),true,cellIds1D);
- MCAuto<DataArrayInt> cellIds1DTmp(cellIds1D);
+ MCAuto<DataArrayIdType> cellIds1DTmp(cellIds1D);
//
- std::vector<int> cut3DCurve(mDesc1->getNumberOfCells(),-2);
- for(const int *it=cellIds1D->begin();it!=cellIds1D->end();it++)
+ std::vector<mcIdType> cut3DCurve(mDesc1->getNumberOfCells(),-2);
+ for(const mcIdType *it=cellIds1D->begin();it!=cellIds1D->end();it++)
cut3DCurve[*it]=-1;
mDesc1->split3DCurveWithPlane(origin,vec,eps,cut3DCurve);
- std::vector< std::pair<int,int> > cut3DSurf(mDesc2->getNumberOfCells());
+ std::vector< std::pair<mcIdType,mcIdType> > cut3DSurf(mDesc2->getNumberOfCells());
AssemblyForSplitFrom3DCurve(cut3DCurve,nodes,mDesc2->getNodalConnectivity()->getConstPointer(),mDesc2->getNodalConnectivityIndex()->getConstPointer(),
mDesc1->getNodalConnectivity()->getConstPointer(),mDesc1->getNodalConnectivityIndex()->getConstPointer(),
desc1->getConstPointer(),descIndx1->getConstPointer(),cut3DSurf);
- MCAuto<DataArrayInt> conn(DataArrayInt::New()),connI(DataArrayInt::New()),cellIds2(DataArrayInt::New());
+ MCAuto<DataArrayIdType> conn(DataArrayIdType::New()),connI(DataArrayIdType::New()),cellIds2(DataArrayIdType::New());
connI->pushBackSilent(0); conn->alloc(0,1); cellIds2->alloc(0,1);
subMesh->assemblyForSplitFrom3DSurf(cut3DSurf,desc2->getConstPointer(),descIndx2->getConstPointer(),conn,connI,cellIds2);
if(cellIds2->empty())
/*!
* Creates an 1D mesh by cutting \a this 2D mesh in 3D space with a plane. In
-addition to the mesh, returns a new DataArrayInt, of length equal to the number of 1D cells in the result mesh, holding, for each cell in the result mesh, an id of a 2D cell it comes
+addition to the mesh, returns a new DataArrayIdType, of length equal to the number of 1D cells in the result mesh, holding, for each cell in the result mesh, an id of a 2D cell it comes
from. If a result segment is shared by two 2D cells, then the segment in included twice in
the result mesh.
* \param [in] origin - 3 components of a point defining location of the plane.
* \param [in] vec - 3 components of a vector normal to the plane. Vector magnitude
* must be greater than 1e-6.
* \param [in] eps - half-thickness of the plane.
- * \param [out] cellIds - a new instance of DataArrayInt holding ids of faces
+ * \param [out] cellIds - a new instance of DataArrayIdType holding ids of faces
* producing correspondent segments. The caller is to delete this array
* using decrRef() as it is no more needed.
* \return MEDCouplingUMesh * - a new instance of MEDCouplingUMesh. This is an 1D
* mesh in 3D space. This mesh does not share the node coordinates array with
* \a this mesh. The caller is to delete this mesh using decrRef() as it is
- * no more needed.
+ * no more needed.
* \throw If the coordinates array is not set.
* \throw If the nodal connectivity of cells is not defined.
* \throw If \a this->getMeshDimension() != 2 or \a this->getSpaceDimension() != 3.
* \throw If the plane does not intersect any 2D cell of \a this mesh.
* \throw If \a this includes quadratic cells.
*/
-MEDCouplingUMesh *MEDCouplingUMesh::buildSlice3DSurf(const double *origin, const double *vec, double eps, DataArrayInt *&cellIds) const
+MEDCouplingUMesh *MEDCouplingUMesh::buildSlice3DSurf(const double *origin, const double *vec, double eps, DataArrayIdType *&cellIds) const
{
checkFullyDefined();
if(getMeshDimension()!=2 || getSpaceDimension()!=3)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::buildSlice3DSurf works on umeshes with meshdim equal to 2 and spaceDim equal to 3 !");
- MCAuto<DataArrayInt> candidates(getCellIdsCrossingPlane(origin,vec,eps));
+ MCAuto<DataArrayIdType> candidates(getCellIdsCrossingPlane(origin,vec,eps));
if(candidates->empty())
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::buildSlice3DSurf : No 3D surf cells in this intercepts the specified plane considering bounding boxes !");
- std::vector<int> nodes;
- DataArrayInt *cellIds1D(0);
+ std::vector<mcIdType> nodes;
+ DataArrayIdType *cellIds1D(0);
MCAuto<MEDCouplingUMesh> subMesh(buildPartOfMySelf(candidates->begin(),candidates->end(),false));
subMesh->findNodesOnPlane(origin,vec,eps,nodes);
- MCAuto<DataArrayInt> desc1(DataArrayInt::New()),descIndx1(DataArrayInt::New()),revDesc1(DataArrayInt::New()),revDescIndx1(DataArrayInt::New());
+ MCAuto<DataArrayIdType> desc1(DataArrayIdType::New()),descIndx1(DataArrayIdType::New()),revDesc1(DataArrayIdType::New()),revDescIndx1(DataArrayIdType::New());
MCAuto<MEDCouplingUMesh> mDesc1(subMesh->buildDescendingConnectivity(desc1,descIndx1,revDesc1,revDescIndx1));//meshDim==1 spaceDim==3
mDesc1->fillCellIdsToKeepFromNodeIds(&nodes[0],&nodes[0]+nodes.size(),true,cellIds1D);
- MCAuto<DataArrayInt> cellIds1DTmp(cellIds1D);
+ MCAuto<DataArrayIdType> cellIds1DTmp(cellIds1D);
//
- std::vector<int> cut3DCurve(mDesc1->getNumberOfCells(),-2);
- for(const int *it=cellIds1D->begin();it!=cellIds1D->end();it++)
+ std::vector<mcIdType> cut3DCurve(mDesc1->getNumberOfCells(),-2);
+ for(const mcIdType *it=cellIds1D->begin();it!=cellIds1D->end();it++)
cut3DCurve[*it]=-1;
mDesc1->split3DCurveWithPlane(origin,vec,eps,cut3DCurve);
- int ncellsSub=subMesh->getNumberOfCells();
- std::vector< std::pair<int,int> > cut3DSurf(ncellsSub);
+ mcIdType ncellsSub=subMesh->getNumberOfCells();
+ std::vector< std::pair<mcIdType,mcIdType> > cut3DSurf(ncellsSub);
AssemblyForSplitFrom3DCurve(cut3DCurve,nodes,subMesh->getNodalConnectivity()->getConstPointer(),subMesh->getNodalConnectivityIndex()->getConstPointer(),
mDesc1->getNodalConnectivity()->getConstPointer(),mDesc1->getNodalConnectivityIndex()->getConstPointer(),
desc1->getConstPointer(),descIndx1->getConstPointer(),cut3DSurf);
- MCAuto<DataArrayInt> conn(DataArrayInt::New()),connI(DataArrayInt::New()),cellIds2(DataArrayInt::New()); connI->pushBackSilent(0);
+ MCAuto<DataArrayIdType> conn(DataArrayIdType::New()),connI(DataArrayIdType::New()),cellIds2(DataArrayIdType::New()); connI->pushBackSilent(0);
conn->alloc(0,1);
- const int *nodal=subMesh->getNodalConnectivity()->getConstPointer();
- const int *nodalI=subMesh->getNodalConnectivityIndex()->getConstPointer();
- for(int i=0;i<ncellsSub;i++)
+ const mcIdType *nodal=subMesh->getNodalConnectivity()->getConstPointer();
+ const mcIdType *nodalI=subMesh->getNodalConnectivityIndex()->getConstPointer();
+ for(mcIdType i=0;i<ncellsSub;i++)
{
if(cut3DSurf[i].first!=-1 && cut3DSurf[i].second!=-1)
{
if(cut3DSurf[i].first!=-2)
{
- conn->pushBackSilent((int)INTERP_KERNEL::NORM_SEG2); conn->pushBackSilent(cut3DSurf[i].first); conn->pushBackSilent(cut3DSurf[i].second);
+ conn->pushBackSilent(ToIdType(INTERP_KERNEL::NORM_SEG2)); conn->pushBackSilent(cut3DSurf[i].first); conn->pushBackSilent(cut3DSurf[i].second);
connI->pushBackSilent(conn->getNumberOfTuples());
cellIds2->pushBackSilent(i);
}
else
{
- int cellId3DSurf=cut3DSurf[i].second;
- int offset=nodalI[cellId3DSurf]+1;
- int nbOfEdges=nodalI[cellId3DSurf+1]-offset;
- for(int j=0;j<nbOfEdges;j++)
+ mcIdType cellId3DSurf=cut3DSurf[i].second;
+ mcIdType offset=nodalI[cellId3DSurf]+1;
+ mcIdType nbOfEdges=nodalI[cellId3DSurf+1]-offset;
+ for(mcIdType j=0;j<nbOfEdges;j++)
{
- conn->pushBackSilent((int)INTERP_KERNEL::NORM_SEG2); conn->pushBackSilent(nodal[offset+j]); conn->pushBackSilent(nodal[offset+(j+1)%nbOfEdges]);
+ conn->pushBackSilent(ToIdType(INTERP_KERNEL::NORM_SEG2)); conn->pushBackSilent(nodal[offset+j]); conn->pushBackSilent(nodal[offset+(j+1)%nbOfEdges]);
connI->pushBackSilent(conn->getNumberOfTuples());
cellIds2->pushBackSilent(cellId3DSurf);
}
if(getNumberOfCells()!=1)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::clipSingle3DCellByPlane works only on mesh containing exactly one cell !");
//
- std::vector<int> nodes;
+ std::vector<mcIdType> nodes;
findNodesOnPlane(origin,vec,eps,nodes);
- MCAuto<DataArrayInt> desc1(DataArrayInt::New()),desc2(DataArrayInt::New()),descIndx1(DataArrayInt::New()),descIndx2(DataArrayInt::New()),revDesc1(DataArrayInt::New()),revDesc2(DataArrayInt::New()),revDescIndx1(DataArrayInt::New()),revDescIndx2(DataArrayInt::New());
+ MCAuto<DataArrayIdType> desc1(DataArrayIdType::New()),desc2(DataArrayIdType::New()),descIndx1(DataArrayIdType::New()),descIndx2(DataArrayIdType::New()),revDesc1(DataArrayIdType::New()),revDesc2(DataArrayIdType::New()),revDescIndx1(DataArrayIdType::New()),revDescIndx2(DataArrayIdType::New());
MCAuto<MEDCouplingUMesh> mDesc2(buildDescendingConnectivity(desc2,descIndx2,revDesc2,revDescIndx2));//meshDim==2 spaceDim==3
revDesc2=0; revDescIndx2=0;
MCAuto<MEDCouplingUMesh> mDesc1(mDesc2->buildDescendingConnectivity(desc1,descIndx1,revDesc1,revDescIndx1));//meshDim==1 spaceDim==3
revDesc1=0; revDescIndx1=0;
- DataArrayInt *cellIds1D(0);
+ DataArrayIdType *cellIds1D(0);
mDesc1->fillCellIdsToKeepFromNodeIds(&nodes[0],&nodes[0]+nodes.size(),true,cellIds1D);
- MCAuto<DataArrayInt> cellIds1DTmp(cellIds1D);
- std::vector<int> cut3DCurve(mDesc1->getNumberOfCells(),-2);
- for(const int *it=cellIds1D->begin();it!=cellIds1D->end();it++)
+ MCAuto<DataArrayIdType> cellIds1DTmp(cellIds1D);
+ std::vector<mcIdType> cut3DCurve(mDesc1->getNumberOfCells(),-2);
+ for(const mcIdType *it=cellIds1D->begin();it!=cellIds1D->end();it++)
cut3DCurve[*it]=-1;
bool sameNbNodes;
{
- int oldNbNodes(mDesc1->getNumberOfNodes());
+ mcIdType oldNbNodes(mDesc1->getNumberOfNodes());
mDesc1->split3DCurveWithPlane(origin,vec,eps,cut3DCurve);
sameNbNodes=(mDesc1->getNumberOfNodes()==oldNbNodes);
}
- std::vector< std::pair<int,int> > cut3DSurf(mDesc2->getNumberOfCells());
+ std::vector< std::pair<mcIdType,mcIdType> > cut3DSurf(mDesc2->getNumberOfCells());
AssemblyForSplitFrom3DCurve(cut3DCurve,nodes,mDesc2->getNodalConnectivity()->begin(),mDesc2->getNodalConnectivityIndex()->begin(),
mDesc1->getNodalConnectivity()->begin(),mDesc1->getNodalConnectivityIndex()->begin(),
desc1->begin(),descIndx1->begin(),cut3DSurf);
- MCAuto<DataArrayInt> conn(DataArrayInt::New()),connI(DataArrayInt::New());
+ MCAuto<DataArrayIdType> conn(DataArrayIdType::New()),connI(DataArrayIdType::New());
connI->pushBackSilent(0); conn->alloc(0,1);
{
- MCAuto<DataArrayInt> cellIds2(DataArrayInt::New()); cellIds2->alloc(0,1);
+ MCAuto<DataArrayIdType> cellIds2(DataArrayIdType::New()); cellIds2->alloc(0,1);
assemblyForSplitFrom3DSurf(cut3DSurf,desc2->begin(),descIndx2->begin(),conn,connI,cellIds2);
if(cellIds2->empty())
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::buildSlice3D : No 3D cells in this intercepts the specified plane !");
}
- std::vector<std::vector<int> > res;
+ std::vector<std::vector<mcIdType> > res;
buildSubCellsFromCut(cut3DSurf,desc2->begin(),descIndx2->begin(),mDesc1->getCoords()->begin(),eps,res);
std::size_t sz(res.size());
- if(res.size()==mDesc1->getNumberOfCells() && sameNbNodes)
+ if(ToIdType(res.size())==mDesc1->getNumberOfCells() && sameNbNodes)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::clipSingle3DCellByPlane : cell is not clipped !");
for(std::size_t i=0;i<sz;i++)
{
- conn->pushBackSilent((int)INTERP_KERNEL::NORM_POLYGON);
+ conn->pushBackSilent(ToIdType(INTERP_KERNEL::NORM_POLYGON));
conn->insertAtTheEnd(res[i].begin(),res[i].end());
connI->pushBackSilent(conn->getNumberOfTuples());
}
MCAuto<MEDCouplingUMesh> ret(MEDCouplingUMesh::New("",2));
ret->setCoords(mDesc1->getCoords());
ret->setConnectivity(conn,connI,true);
- int nbCellsRet(ret->getNumberOfCells());
+ mcIdType nbCellsRet(ret->getNumberOfCells());
//
MCAuto<DataArrayDouble> vec2(DataArrayDouble::New()); vec2->alloc(1,3); std::copy(vec,vec+3,vec2->getPointer());
MCAuto<MEDCouplingFieldDouble> ortho(ret->buildOrthogonalField());
vec2->setPartOfValuesSimple1(vec[0],0,nbCellsRet,1,0,1,1); vec2->setPartOfValuesSimple1(vec[1],0,nbCellsRet,1,1,2,1); vec2->setPartOfValuesSimple1(vec[2],0,nbCellsRet,1,2,3,1);
MCAuto<DataArrayDouble> dott2(DataArrayDouble::Dot(occm,vec2));
//
- const int *cPtr(ret->getNodalConnectivity()->begin()),*ciPtr(ret->getNodalConnectivityIndex()->begin());
+ const mcIdType *cPtr(ret->getNodalConnectivity()->begin()),*ciPtr(ret->getNodalConnectivityIndex()->begin());
MCAuto<MEDCouplingUMesh> ret2(MEDCouplingUMesh::New("Clip3D",3));
ret2->setCoords(mDesc1->getCoords());
- MCAuto<DataArrayInt> conn2(DataArrayInt::New()),conn2I(DataArrayInt::New());
+ MCAuto<DataArrayIdType> conn2(DataArrayIdType::New()),conn2I(DataArrayIdType::New());
conn2I->pushBackSilent(0); conn2->alloc(0,1);
- std::vector<int> cell0(1,(int)INTERP_KERNEL::NORM_POLYHED);
- std::vector<int> cell1(1,(int)INTERP_KERNEL::NORM_POLYHED);
+ std::vector<mcIdType> cell0(1,ToIdType(INTERP_KERNEL::NORM_POLYHED));
+ std::vector<mcIdType> cell1(1,ToIdType(INTERP_KERNEL::NORM_POLYHED));
if(dott->getIJ(0,0)>0)
{
cell0.insert(cell0.end(),cPtr+1,cPtr+ciPtr[1]);
cell1.insert(cell1.end(),cPtr+1,cPtr+ciPtr[1]);
std::reverse_copy(cPtr+1,cPtr+ciPtr[1],std::inserter(cell0,cell0.end()));
}
- for(int i=1;i<nbCellsRet;i++)
+ for(mcIdType i=1;i<nbCellsRet;i++)
{
if(dott2->getIJ(i,0)<0)
{
* \param [in] vec - 3 components of a vector normal to the plane. Vector magnitude
* must be greater than 1e-6.
* \param [in] eps - half-thickness of the plane.
- * \return DataArrayInt * - a new instance of DataArrayInt holding ids of the found
+ * \return DataArrayIdType * - a new instance of DataArrayIdType holding ids of the found
* cells. The caller is to delete this array using decrRef() as it is no more
* needed.
* \throw If the coordinates array is not set.
* \throw If magnitude of \a vec is less than 1e-6.
* \sa buildSlice3D()
*/
-DataArrayInt *MEDCouplingUMesh::getCellIdsCrossingPlane(const double *origin, const double *vec, double eps) const
+DataArrayIdType *MEDCouplingUMesh::getCellIdsCrossingPlane(const double *origin, const double *vec, double eps) const
{
checkFullyDefined();
if(getSpaceDimension()!=3)
double vec2[3];
vec2[0]=vec[1]; vec2[1]=-vec[0]; vec2[2]=0.;//vec2 is the result of cross product of vec with (0,0,1)
double angle=acos(vec[2]/normm);
- MCAuto<DataArrayInt> cellIds;
+ MCAuto<DataArrayIdType> cellIds;
double bbox[6];
if(angle>eps)
{
{
if(getMeshDimension()!=1)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::isContiguous1D : this method has a sense only for 1D mesh !");
- int nbCells=getNumberOfCells();
+ mcIdType nbCells=getNumberOfCells();
if(nbCells<1)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::isContiguous1D : this method has a sense for non empty mesh !");
- const int *connI(_nodal_connec_index->begin()),*conn(_nodal_connec->begin());
- int ref=conn[connI[0]+2];
- for(int i=1;i<nbCells;i++)
+ const mcIdType *connI(_nodal_connec_index->begin()),*conn(_nodal_connec->begin());
+ mcIdType ref=conn[connI[0]+2];
+ for(mcIdType i=1;i<nbCells;i++)
{
if(conn[connI[i]+1]!=ref)
return false;
MCAuto<MEDCouplingFieldDouble> f=buildDirectionVectorField();
const double *fPtr=f->getArray()->getConstPointer();
double tmp[3];
- for(std::size_t i=0;i<getNumberOfCells();i++)
+ for(mcIdType i=0;i<getNumberOfCells();i++)
{
const double *tmp1=fPtr+3*i;
tmp[0]=tmp1[1]*v[2]-tmp1[2]*v[1];
throw INTERP_KERNEL::Exception("UMesh::Projection 1D failed !");
}
const double *coo=getCoords()->getConstPointer();
- for(int i=0;i<getNumberOfNodes();i++)
+ for(mcIdType i=0;i<getNumberOfNodes();i++)
{
std::transform(coo+i*3,coo+i*3+3,pt,tmp,std::minus<double>());
std::transform(tmp,tmp+3,v,tmp,std::multiplies<double>());
}
/*!
- * This method computes the distance from a point \a pt to \a this and the first \a cellId in \a this corresponding to the returned distance.
+ * This method computes the distance from a point \a pt to \a this and the first \a cellId in \a this corresponding to the returned distance.
* \a this is expected to be a mesh so that its space dimension is equal to its
* mesh dimension + 1. Furthermore only mesh dimension 1 and 2 are supported for the moment.
* Distance from \a ptBg to \a ptEnd is expected to be equal to the space dimension. \a this is also expected to be fully defined (connectivity and coordinates).
* dimension - 1.
* \sa DataArrayDouble::distanceToTuple, MEDCouplingUMesh::distanceToPoints
*/
-double MEDCouplingUMesh::distanceToPoint(const double *ptBg, const double *ptEnd, int& cellId) const
+double MEDCouplingUMesh::distanceToPoint(const double *ptBg, const double *ptEnd, mcIdType& cellId) const
{
int meshDim=getMeshDimension(),spaceDim=getSpaceDimension();
if(meshDim!=spaceDim-1)
if(meshDim!=2 && meshDim!=1)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::distanceToPoint : only mesh dimension 2 and 1 are implemented !");
checkFullyDefined();
- if((int)std::distance(ptBg,ptEnd)!=spaceDim)
+ if(ToIdType(std::distance(ptBg,ptEnd))!=spaceDim)
{ std::ostringstream oss; oss << "MEDCouplingUMesh::distanceToPoint : input point has to have dimension equal to the space dimension of this (" << spaceDim << ") !"; throw INTERP_KERNEL::Exception(oss.str()); }
- DataArrayInt *ret1=0;
- MCAuto<DataArrayDouble> pts=DataArrayDouble::New(); pts->useArray(ptBg,false,C_DEALLOC,1,spaceDim);
+ DataArrayIdType *ret1=0;
+ MCAuto<DataArrayDouble> pts=DataArrayDouble::New(); pts->useArray(ptBg,false,DeallocType::C_DEALLOC,1,spaceDim);
MCAuto<DataArrayDouble> ret0=distanceToPoints(pts,ret1);
- MCAuto<DataArrayInt> ret1Safe(ret1);
+ MCAuto<DataArrayIdType> ret1Safe(ret1);
cellId=*ret1Safe->begin();
return *ret0->begin();
}
/*!
* This method computes the distance from each point of points serie \a pts (stored in a DataArrayDouble in which each tuple represents a point)
- * to \a this and the first \a cellId in \a this corresponding to the returned distance.
+ * to \a this and the first \a cellId in \a this corresponding to the returned distance.
* WARNING, if there is some orphan nodes in \a this (nodes not fetched by any cells in \a this ( see MEDCouplingUMesh::zipCoords ) ) these nodes will ** not ** been taken
* into account in this method. Only cells and nodes lying on them are considered in the algorithm (even if one of these orphan nodes is closer than returned distance).
* A user that needs to consider orphan nodes should invoke DataArrayDouble::minimalDistanceTo method on the coordinates array of \a this.
- *
+ *
* \a this is expected to be a mesh so that its space dimension is equal to its
* mesh dimension + 1. Furthermore only mesh dimension 1 and 2 are supported for the moment.
* Number of components of \a pts is expected to be equal to the space dimension. \a this is also expected to be fully defined (connectivity and coordinates).
* \throw if mesh dimension of \a this is not equal to space dimension - 1.
* \sa DataArrayDouble::distanceToTuple, MEDCouplingUMesh::distanceToPoint
*/
-DataArrayDouble *MEDCouplingUMesh::distanceToPoints(const DataArrayDouble *pts, DataArrayInt *& cellIds) const
+DataArrayDouble *MEDCouplingUMesh::distanceToPoints(const DataArrayDouble *pts, DataArrayIdType *& cellIds) const
{
if(!pts)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::distanceToPoints : input points pointer is NULL !");
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::distanceToPoints works only for spaceDim=meshDim+1 !");
if(meshDim!=2 && meshDim!=1)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::distanceToPoints : only mesh dimension 2 and 1 are implemented !");
- if((int)pts->getNumberOfComponents()!=spaceDim)
+ if(ToIdType(pts->getNumberOfComponents())!=spaceDim)
{
std::ostringstream oss; oss << "MEDCouplingUMesh::distanceToPoints : input pts DataArrayDouble has " << pts->getNumberOfComponents() << " components whereas it should be equal to " << spaceDim << " (mesh spaceDimension) !";
throw INTERP_KERNEL::Exception(oss.str());
}
checkFullyDefined();
- int nbCells=getNumberOfCells();
+ mcIdType nbCells=getNumberOfCells();
if(nbCells==0)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::distanceToPoints : no cells in this !");
- int nbOfPts=pts->getNumberOfTuples();
+ mcIdType nbOfPts=pts->getNumberOfTuples();
MCAuto<DataArrayDouble> ret0=DataArrayDouble::New(); ret0->alloc(nbOfPts,1);
- MCAuto<DataArrayInt> ret1=DataArrayInt::New(); ret1->alloc(nbOfPts,1);
- const int *nc=_nodal_connec->begin(),*ncI=_nodal_connec_index->begin(); const double *coords=_coords->begin();
- double *ret0Ptr=ret0->getPointer(); int *ret1Ptr=ret1->getPointer(); const double *ptsPtr=pts->begin();
+ MCAuto<DataArrayIdType> ret1=DataArrayIdType::New(); ret1->alloc(nbOfPts,1);
+ const mcIdType *nc=_nodal_connec->begin(),*ncI=_nodal_connec_index->begin(); const double *coords=_coords->begin();
+ double *ret0Ptr=ret0->getPointer(); mcIdType *ret1Ptr=ret1->getPointer(); const double *ptsPtr=pts->begin();
MCAuto<DataArrayDouble> bboxArr(getBoundingBoxForBBTree());
const double *bbox(bboxArr->begin());
switch(spaceDim)
case 3:
{
BBTreeDst<3> myTree(bbox,0,0,nbCells);
- for(int i=0;i<nbOfPts;i++,ret0Ptr++,ret1Ptr++,ptsPtr+=3)
+ for(mcIdType i=0;i<nbOfPts;i++,ret0Ptr++,ret1Ptr++,ptsPtr+=3)
{
double x=std::numeric_limits<double>::max();
- std::vector<int> elems;
+ std::vector<mcIdType> elems;
myTree.getMinDistanceOfMax(ptsPtr,x);
myTree.getElemsWhoseMinDistanceToPtSmallerThan(ptsPtr,x,elems);
DistanceToPoint3DSurfAlg(ptsPtr,&elems[0],&elems[0]+elems.size(),coords,nc,ncI,*ret0Ptr,*ret1Ptr);
case 2:
{
BBTreeDst<2> myTree(bbox,0,0,nbCells);
- for(int i=0;i<nbOfPts;i++,ret0Ptr++,ret1Ptr++,ptsPtr+=2)
+ for(mcIdType i=0;i<nbOfPts;i++,ret0Ptr++,ret1Ptr++,ptsPtr+=2)
{
double x=std::numeric_limits<double>::max();
- std::vector<int> elems;
+ std::vector<mcIdType> elems;
myTree.getMinDistanceOfMax(ptsPtr,x);
myTree.getElemsWhoseMinDistanceToPtSmallerThan(ptsPtr,x,elems);
DistanceToPoint2DCurveAlg(ptsPtr,&elems[0],&elems[0]+elems.size(),coords,nc,ncI,*ret0Ptr,*ret1Ptr);
/// @endcond
/*!
- * Finds cells in contact with a ball (i.e. a point with precision).
+ * Finds cells in contact with a ball (i.e. a point with precision).
* For speed reasons, the INTERP_KERNEL::NORM_QUAD4, INTERP_KERNEL::NORM_TRI6 and INTERP_KERNEL::NORM_QUAD8 cells are considered as convex cells to detect if a point is IN or OUT.
* If it is not the case, please change their types to INTERP_KERNEL::NORM_POLYGON or INTERP_KERNEL::NORM_QPOLYG before invoking this method.
*
* \warning This method is suitable if the caller intends to evaluate only one
* point, for more points getCellsContainingPoints() is recommended as it is
- * faster.
+ * faster.
* \param [in] pos - array of coordinates of the ball central point.
* \param [in] eps - ball radius.
- * \return int - a smallest id of cells being in contact with the ball, -1 in case
+ * \return mcIdType - a smallest id of cells being in contact with the ball, -1 in case
* if there are no such cells.
* \throw If the coordinates array is not set.
* \throw If \a this->getMeshDimension() != \a this->getSpaceDimension().
*/
-int MEDCouplingUMesh::getCellContainingPoint(const double *pos, double eps) const
+mcIdType MEDCouplingUMesh::getCellContainingPoint(const double *pos, double eps) const
{
- std::vector<int> elts;
+ std::vector<mcIdType> elts;
getCellsContainingPoint(pos,eps,elts);
if(elts.empty())
return -1;
* If it is not the case, please change their types to INTERP_KERNEL::NORM_POLYGON or INTERP_KERNEL::NORM_QPOLYG before invoking this method.
* \warning This method is suitable if the caller intends to evaluate only one
* point, for more points getCellsContainingPoints() is recommended as it is
- * faster.
+ * faster.
* \param [in] pos - array of coordinates of the ball central point.
* \param [in] eps - ball radius.
* \param [out] elts - vector returning ids of the found cells. It is cleared
* \ref py_mcumesh_getCellsContainingPoint "Here is a Python example".
* \endif
*/
-void MEDCouplingUMesh::getCellsContainingPoint(const double *pos, double eps, std::vector<int>& elts) const
+void MEDCouplingUMesh::getCellsContainingPoint(const double *pos, double eps, std::vector<mcIdType>& elts) const
{
- MCAuto<DataArrayInt> eltsUg,eltsIndexUg;
+ MCAuto<DataArrayIdType> eltsUg,eltsIndexUg;
getCellsContainingPoints(pos,1,eps,eltsUg,eltsIndexUg);
elts.clear(); elts.insert(elts.end(),eltsUg->begin(),eltsUg->end());
}
-void MEDCouplingUMesh::getCellsContainingPointsZeAlg(const double *pos, int nbOfPoints, double eps,
- MCAuto<DataArrayInt>& elts, MCAuto<DataArrayInt>& eltsIndex,
- std::function<bool(INTERP_KERNEL::NormalizedCellType,int)> sensibilityTo2DQuadraticLinearCellsFunc) const
+void MEDCouplingUMesh::getCellsContainingPointsZeAlg(const double *pos, mcIdType nbOfPoints, double eps,
+ MCAuto<DataArrayIdType>& elts, MCAuto<DataArrayIdType>& eltsIndex,
+ std::function<bool(INTERP_KERNEL::NormalizedCellType,mcIdType)> sensibilityTo2DQuadraticLinearCellsFunc) const
{
int spaceDim(getSpaceDimension()),mDim(getMeshDimension());
if(spaceDim==3)
* If it is not the case, please change their types to INTERP_KERNEL::NORM_POLYGON or INTERP_KERNEL::NORM_QPOLYG before invoking this method.
* \param [in] pos - an array of coordinates of points in full interlace mode :
* X0,Y0,Z0,X1,Y1,Z1,... Size of the array must be \a
- * this->getSpaceDimension() * \a nbOfPoints
+ * this->getSpaceDimension() * \a nbOfPoints
* \param [in] nbOfPoints - number of points to locate within \a this mesh.
* \param [in] eps - radius of balls (i.e. the precision).
* \param [out] elts - vector returning ids of found cells.
* \ref py_mcumesh_getCellsContainingPoints "Here is a Python example".
* \endif
*/
-void MEDCouplingUMesh::getCellsContainingPoints(const double *pos, int nbOfPoints, double eps,
- MCAuto<DataArrayInt>& elts, MCAuto<DataArrayInt>& eltsIndex) const
+void MEDCouplingUMesh::getCellsContainingPoints(const double *pos, mcIdType nbOfPoints, double eps,
+ MCAuto<DataArrayIdType>& elts, MCAuto<DataArrayIdType>& eltsIndex) const
{
auto yesImSensibleTo2DQuadraticLinearCellsFunc([](INTERP_KERNEL::NormalizedCellType ct, int mdim) { return INTERP_KERNEL::CellModel::GetCellModel(ct).isQuadratic() && mdim == 2; } );
this->getCellsContainingPointsZeAlg(pos,nbOfPoints,eps,elts,eltsIndex,yesImSensibleTo2DQuadraticLinearCellsFunc);
*
* \sa MEDCouplingUMesh::getCellsContainingPoints, MEDCouplingRemapper::prepareNotInterpKernelOnlyGaussGauss
*/
-void MEDCouplingUMesh::getCellsContainingPointsLinearPartOnlyOnNonDynType(const double *pos, int nbOfPoints, double eps, MCAuto<DataArrayInt>& elts, MCAuto<DataArrayInt>& eltsIndex) const
+void MEDCouplingUMesh::getCellsContainingPointsLinearPartOnlyOnNonDynType(const double *pos, mcIdType nbOfPoints, double eps, MCAuto<DataArrayIdType>& elts, MCAuto<DataArrayIdType>& eltsIndex) const
{
- auto noImNotSensibleTo2DQuadraticLinearCellsFunc([](INTERP_KERNEL::NormalizedCellType,int) { return false; } );
+ auto noImNotSensibleTo2DQuadraticLinearCellsFunc([](INTERP_KERNEL::NormalizedCellType,mcIdType) { return false; } );
this->getCellsContainingPointsZeAlg(pos,nbOfPoints,eps,elts,eltsIndex,noImNotSensibleTo2DQuadraticLinearCellsFunc);
}
* \throw If \a this->getMeshDimension() != 2.
* \throw If \a this->getSpaceDimension() != 2 && \a this->getSpaceDimension() != 3.
*/
-void MEDCouplingUMesh::checkButterflyCells(std::vector<int>& cells, double eps) const
+void MEDCouplingUMesh::checkButterflyCells(std::vector<mcIdType>& cells, double eps) const
{
const char msg[]="Butterfly detection work only for 2D cells with spaceDim==2 or 3!";
if(getMeshDimension()!=2)
int spaceDim=getSpaceDimension();
if(spaceDim!=2 && spaceDim!=3)
throw INTERP_KERNEL::Exception(msg);
- const int *conn=_nodal_connec->getConstPointer();
- const int *connI=_nodal_connec_index->getConstPointer();
- int nbOfCells=getNumberOfCells();
+ const mcIdType *conn=_nodal_connec->getConstPointer();
+ const mcIdType *connI=_nodal_connec_index->getConstPointer();
+ mcIdType nbOfCells=getNumberOfCells();
std::vector<double> cell2DinS2;
- for(int i=0;i<nbOfCells;i++)
+ for(mcIdType i=0;i<nbOfCells;i++)
{
- int offset=connI[i];
- int nbOfNodesForCell=connI[i+1]-offset-1;
+ mcIdType offset=connI[i];
+ mcIdType nbOfNodesForCell=connI[i+1]-offset-1;
if(nbOfNodesForCell<=3)
continue;
bool isQuad=INTERP_KERNEL::CellModel::GetCellModel((INTERP_KERNEL::NormalizedCellType)conn[offset]).isQuadratic();
*
* This method expects that space dimension is equal to 2 and mesh dimension is equal to 2 too. If it is not the case an INTERP_KERNEL::Exception will be thrown.
* This method works only for linear 2D cells. If there is any of non linear cells (INTERP_KERNEL::NORM_QUAD8 for example) an INTERP_KERNEL::Exception will be thrown too.
- *
+ *
* For each 2D linear cell in \b this, this method builds the convex envelop (or the convex hull) of the current cell.
* This convex envelop is computed using Jarvis march algorithm.
* The coordinates and the number of cells of \b this remain unchanged on invocation of this method.
* \return a newly allocated array containing cellIds that have been modified if any. If no cells have been impacted by this method NULL is returned.
* \sa MEDCouplingUMesh::colinearize2D
*/
-DataArrayInt *MEDCouplingUMesh::convexEnvelop2D()
+DataArrayIdType *MEDCouplingUMesh::convexEnvelop2D()
{
if(getMeshDimension()!=2 || getSpaceDimension()!=2)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::convexEnvelop2D works only for meshDim=2 and spaceDim=2 !");
checkFullyDefined();
const double *coords=getCoords()->getConstPointer();
- int nbOfCells=getNumberOfCells();
- MCAuto<DataArrayInt> nodalConnecIndexOut=DataArrayInt::New();
+ mcIdType nbOfCells=getNumberOfCells();
+ MCAuto<DataArrayIdType> nodalConnecIndexOut=DataArrayIdType::New();
nodalConnecIndexOut->alloc(nbOfCells+1,1);
- MCAuto<DataArrayInt> nodalConnecOut(DataArrayInt::New());
- int *workIndexOut=nodalConnecIndexOut->getPointer();
+ MCAuto<DataArrayIdType> nodalConnecOut(DataArrayIdType::New());
+ mcIdType *workIndexOut=nodalConnecIndexOut->getPointer();
*workIndexOut=0;
- const int *nodalConnecIn=_nodal_connec->getConstPointer();
- const int *nodalConnecIndexIn=_nodal_connec_index->getConstPointer();
+ const mcIdType *nodalConnecIn=_nodal_connec->getConstPointer();
+ const mcIdType *nodalConnecIndexIn=_nodal_connec_index->getConstPointer();
std::set<INTERP_KERNEL::NormalizedCellType> types;
- MCAuto<DataArrayInt> isChanged(DataArrayInt::New());
+ MCAuto<DataArrayIdType> isChanged(DataArrayIdType::New());
isChanged->alloc(0,1);
- for(int i=0;i<nbOfCells;i++,workIndexOut++)
+ for(mcIdType i=0;i<nbOfCells;i++,workIndexOut++)
{
- int pos=nodalConnecOut->getNumberOfTuples();
+ mcIdType pos=nodalConnecOut->getNumberOfTuples();
if(BuildConvexEnvelopOf2DCellJarvis(coords,nodalConnecIn+nodalConnecIndexIn[i],nodalConnecIn+nodalConnecIndexIn[i+1],nodalConnecOut))
isChanged->pushBackSilent(i);
types.insert((INTERP_KERNEL::NormalizedCellType)nodalConnecOut->getIJ(pos,0));
* the 3 preceding points of the 1D mesh. The center of the arc is the center of rotation for each level, the rotation is done
* along an axis normal to the plane containing the arc, and finally the angle of rotation is defined by the first two points on the
* arc.
- * \return an unstructured mesh with meshDim==3 and spaceDim==3. The returned mesh has the same coords than \a this.
+ * \return an unstructured mesh with meshDim==3 and spaceDim==3. The returned mesh has the same coords than \a this.
*/
MEDCouplingUMesh *MEDCouplingUMesh::buildExtrudedMesh(const MEDCouplingUMesh *mesh1D, int policy)
{
else
throw INTERP_KERNEL::Exception("Invalid 2D mesh and 1D mesh because 2D mesh has quadratic cells and 1D is not fully quadratic !");
}
- int oldNbOfNodes(getNumberOfNodes());
+ mcIdType oldNbOfNodes(getNumberOfNodes());
MCAuto<DataArrayDouble> newCoords;
switch(policy)
{
{
checkFullyDefined();
bool ret=true;
- int nbOfCells=getNumberOfCells();
- for(int i=0;i<nbOfCells && ret;i++)
+ mcIdType nbOfCells=getNumberOfCells();
+ for(mcIdType i=0;i<nbOfCells && ret;i++)
{
INTERP_KERNEL::NormalizedCellType type=getTypeOfCell(i);
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(type);
{
checkFullyDefined();
bool ret=false;
- int nbOfCells=getNumberOfCells();
- for(int i=0;i<nbOfCells && !ret;i++)
+ mcIdType nbOfCells=getNumberOfCells();
+ for(mcIdType i=0;i<nbOfCells && !ret;i++)
{
INTERP_KERNEL::NormalizedCellType type=getTypeOfCell(i);
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(type);
void MEDCouplingUMesh::convertQuadraticCellsToLinear()
{
checkFullyDefined();
- int nbOfCells(getNumberOfCells());
- int delta=0;
- const int *iciptr=_nodal_connec_index->begin();
- for(int i=0;i<nbOfCells;i++)
+ mcIdType nbOfCells=getNumberOfCells();
+ mcIdType delta=0;
+ const mcIdType *iciptr=_nodal_connec_index->begin();
+ for(mcIdType i=0;i<nbOfCells;i++)
{
INTERP_KERNEL::NormalizedCellType type=getTypeOfCell(i);
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(type);
}
if(delta==0)
return ;
- MCAuto<DataArrayInt> newConn(DataArrayInt::New()),newConnI(DataArrayInt::New());
- const int *icptr(_nodal_connec->begin());
+ MCAuto<DataArrayIdType> newConn(DataArrayIdType::New()),newConnI(DataArrayIdType::New());
+ const mcIdType *icptr(_nodal_connec->begin());
newConn->alloc(getNodalConnectivityArrayLen()-delta,1);
newConnI->alloc(nbOfCells+1,1);
- int *ocptr(newConn->getPointer()),*ociptr(newConnI->getPointer());
+ mcIdType *ocptr(newConn->getPointer()),*ociptr(newConnI->getPointer());
*ociptr=0;
_types.clear();
- for(int i=0;i<nbOfCells;i++,ociptr++)
+ for(mcIdType i=0;i<nbOfCells;i++,ociptr++)
{
INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)icptr[iciptr[i]];
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(type);
INTERP_KERNEL::NormalizedCellType typel=cm.getLinearType();
_types.insert(typel);
const INTERP_KERNEL::CellModel& cml=INTERP_KERNEL::CellModel::GetCellModel(typel);
- int newNbOfNodes=cml.getNumberOfNodes();
+ mcIdType newNbOfNodes=cml.getNumberOfNodes();
if(cml.isDynamic())
newNbOfNodes=(iciptr[i+1]-iciptr[i]-1)/2;
- *ocptr++=(int)typel;
+ *ocptr++=ToIdType(typel);
ocptr=std::copy(icptr+iciptr[i]+1,icptr+iciptr[i]+newNbOfNodes+1,ocptr);
ociptr[1]=ociptr[0]+newNbOfNodes+1;
}
* or to INTERP_KERNEL::NORM_TRI7 if \a conversionType is equal to 1. All non linear cells and polyhedron in \a this are let untouched.
* Contrary to MEDCouplingUMesh::convertQuadraticCellsToLinear method, the coordinates in \a this can be become bigger. All created nodes will be put at the
* end of the existing coordinates.
- *
+ *
* \param [in] conversionType specifies the type of conversion expected. Only 0 (default) and 1 are supported presently. 0 those that creates the 'most' simple
* corresponding quadratic cells. 1 is those creating the 'most' complex.
- * \return a newly created DataArrayInt instance that the caller should deal with containing cell ids of converted cells.
- *
+ * \return a newly created DataArrayIdType instance that the caller should deal with containing cell ids of converted cells.
+ *
* \throw if \a this is not fully defined. It throws too if \a conversionType is not in [0,1].
*
* \sa MEDCouplingUMesh::convertQuadraticCellsToLinear
*/
-DataArrayInt *MEDCouplingUMesh::convertLinearCellsToQuadratic(int conversionType)
+DataArrayIdType *MEDCouplingUMesh::convertLinearCellsToQuadratic(int conversionType)
{
- DataArrayInt *conn=0,*connI=0;
+ DataArrayIdType *conn=0,*connI=0;
DataArrayDouble *coords=0;
std::set<INTERP_KERNEL::NormalizedCellType> types;
checkFullyDefined();
- MCAuto<DataArrayInt> ret,connSafe,connISafe;
+ MCAuto<DataArrayIdType> ret,connSafe,connISafe;
MCAuto<DataArrayDouble> coordsSafe;
int meshDim=getMeshDimension();
switch(conversionType)
*
* \sa buildDescendingConnectivity2
*/
-void MEDCouplingUMesh::splitSomeEdgesOf2DMesh(const DataArrayInt *nodeIdsToAdd, const DataArrayInt *nodeIdsIndexToAdd, const DataArrayInt *edgeIdsToBeSplit,
- const MEDCouplingUMesh *mesh1Desc, const DataArrayInt *desc, const DataArrayInt *descI, const DataArrayInt *revDesc, const DataArrayInt *revDescI)
+void MEDCouplingUMesh::splitSomeEdgesOf2DMesh(const DataArrayIdType *nodeIdsToAdd, const DataArrayIdType *nodeIdsIndexToAdd, const DataArrayIdType *edgeIdsToBeSplit,
+ const MEDCouplingUMesh *mesh1Desc, const DataArrayIdType *desc, const DataArrayIdType *descI, const DataArrayIdType *revDesc, const DataArrayIdType *revDescI)
{
if(!nodeIdsToAdd || !nodeIdsIndexToAdd || !edgeIdsToBeSplit || !mesh1Desc || !desc || !descI || !revDesc || !revDescI)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::splitSomeEdgesOf2DMesh : input pointers must be not NULL !");
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::splitSomeEdgesOf2DMesh : this must have spacedim=meshdim=2 !");
if(mesh1Desc->getSpaceDimension()!=2 || mesh1Desc->getMeshDimension()!=1)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::splitSomeEdgesOf2DMesh : mesh1Desc must be the explosion of this with spaceDim=2 and meshDim = 1 !");
- //DataArrayInt *out0(0),*outi0(0);
+ //DataArrayIdType *out0(0),*outi0(0);
//MEDCouplingUMesh::ExtractFromIndexedArrays(idsInDesc2DToBeRefined->begin(),idsInDesc2DToBeRefined->end(),dd3,dd4,out0,outi0);
- //MCAuto<DataArrayInt> out0s(out0),outi0s(outi0);
+ //MCAuto<DataArrayIdType> out0s(out0),outi0s(outi0);
//out0s=out0s->buildUnique(); out0s->sort(true);
}
#endif
* - INTERP_KERNEL::PLANAR_FACE_6 - to split HEXA8 into 6 TETRA4 (for 3D mesh only - see INTERP_KERNEL::SplittingPolicy for an image).
*
*
- * \return DataArrayInt * - a new instance of DataArrayInt holding, for each new cell,
+ * \return DataArrayIdType * - a new instance of DataArrayIdType holding, for each new cell,
* an id of old cell producing it. The caller is to delete this array using
* decrRef() as it is no more needed.
*
* \throw If \a policy is 0 or 1 and \a this->getMeshDimension() != 2.
* \throw If \a policy is INTERP_KERNEL::PLANAR_FACE_5 or INTERP_KERNEL::PLANAR_FACE_6
- * and \a this->getMeshDimension() != 3.
+ * and \a this->getMeshDimension() != 3.
* \throw If \a policy is not one of the four discussed above.
* \throw If the nodal connectivity of cells is not defined.
* \sa MEDCouplingUMesh::tetrahedrize, MEDCoupling1SGTUMesh::sortHexa8EachOther
*/
-DataArrayInt *MEDCouplingUMesh::simplexize(int policy)
+DataArrayIdType *MEDCouplingUMesh::simplexize(int policy)
{
switch(policy)
{
return simplexizePol0();
case 1:
return simplexizePol1();
- case (int) INTERP_KERNEL::PLANAR_FACE_5:
+ case INTERP_KERNEL::PLANAR_FACE_5:
return simplexizePlanarFace5();
- case (int) INTERP_KERNEL::PLANAR_FACE_6:
+ case INTERP_KERNEL::PLANAR_FACE_6:
return simplexizePlanarFace6();
default:
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::simplexize : unrecognized policy ! Must be :\n - 0 or 1 (only available for meshdim=2) \n - PLANAR_FACE_5, PLANAR_FACE_6 (only for meshdim=3)");
int mdim=getMeshDimension();
if(mdim<1 || mdim>3)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::areOnlySimplexCells : only available with meshes having a meshdim 1, 2 or 3 !");
- int nbCells=getNumberOfCells();
- const int *conn=_nodal_connec->begin();
- const int *connI=_nodal_connec_index->begin();
- for(int i=0;i<nbCells;i++)
+ mcIdType nbCells=getNumberOfCells();
+ const mcIdType *conn=_nodal_connec->begin();
+ const mcIdType *connI=_nodal_connec_index->begin();
+ for(mcIdType i=0;i<nbCells;i++)
{
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel((INTERP_KERNEL::NormalizedCellType)conn[connI[i]]);
if(!cm.isSimplex())
checkFullyDefined();
if(getMeshDimension()<=1)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::convertDegeneratedCells works on umeshes with meshdim equals to 2 or 3 !");
- int nbOfCells=getNumberOfCells();
+ mcIdType nbOfCells=getNumberOfCells();
if(nbOfCells<1)
return ;
- int initMeshLgth=getNodalConnectivityArrayLen();
- int *conn=_nodal_connec->getPointer();
- int *index=_nodal_connec_index->getPointer();
- int posOfCurCell=0;
- int newPos=0;
- int lgthOfCurCell;
- for(int i=0;i<nbOfCells;i++)
+ mcIdType initMeshLgth=getNodalConnectivityArrayLen();
+ mcIdType *conn=_nodal_connec->getPointer();
+ mcIdType *index=_nodal_connec_index->getPointer();
+ mcIdType posOfCurCell=0;
+ mcIdType newPos=0;
+ mcIdType lgthOfCurCell;
+ for(mcIdType i=0;i<nbOfCells;i++)
{
lgthOfCurCell=index[i+1]-posOfCurCell;
INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)conn[posOfCurCell];
- int newLgth;
+ mcIdType newLgth;
INTERP_KERNEL::NormalizedCellType newType=INTERP_KERNEL::CellSimplify::simplifyDegeneratedCell(type,conn+posOfCurCell+1,lgthOfCurCell-1,
conn+newPos+1,newLgth);
conn[newPos]=newType;
* - for a linear cell, all points in the connectivity are equal
* - for a quadratic cell, either the above, or a quadratic polygon with two (linear) points and two
* identical quadratic points
- * \return a new instance of DataArrayInt holding ids of removed cells. The caller is to delete
+ * \return a new instance of DataArrayIdType holding ids of removed cells. The caller is to delete
* this array using decrRef() as it is no more needed.
*/
-DataArrayInt *MEDCouplingUMesh::convertDegeneratedCellsAndRemoveFlatOnes()
+DataArrayIdType *MEDCouplingUMesh::convertDegeneratedCellsAndRemoveFlatOnes()
{
checkFullyDefined();
if(getMeshDimension()<=1)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::convertDegeneratedCells works on umeshes with meshdim equals to 2 or 3 !");
- int nbOfCells=getNumberOfCells();
- MCAuto<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
+ mcIdType nbOfCells=getNumberOfCells();
+ MCAuto<DataArrayIdType> ret(DataArrayIdType::New()); ret->alloc(0,1);
if(nbOfCells<1)
return ret.retn();
- int initMeshLgth=getNodalConnectivityArrayLen();
- int *conn=_nodal_connec->getPointer();
- int *index=_nodal_connec_index->getPointer();
- int posOfCurCell=0;
- int newPos=0;
- int lgthOfCurCell, nbDelCells(0);
- for(int i=0;i<nbOfCells;i++)
+ mcIdType initMeshLgth=getNodalConnectivityArrayLen();
+ mcIdType *conn=_nodal_connec->getPointer();
+ mcIdType *index=_nodal_connec_index->getPointer();
+ mcIdType posOfCurCell=0;
+ mcIdType newPos=0;
+ mcIdType lgthOfCurCell, nbDelCells(0);
+ for(mcIdType i=0;i<nbOfCells;i++)
{
lgthOfCurCell=index[i+1]-posOfCurCell;
INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)conn[posOfCurCell];
- int newLgth;
+ mcIdType newLgth;
INTERP_KERNEL::NormalizedCellType newType=INTERP_KERNEL::CellSimplify::simplifyDegeneratedCell(type,conn+posOfCurCell+1,lgthOfCurCell-1,
conn+newPos+1,newLgth);
// Shall we delete the cell if it is completely degenerated:
}
if(newPos!=initMeshLgth)
_nodal_connec->reAlloc(newPos);
- const int nCellDel=ret->getNumberOfTuples();
+ const mcIdType nCellDel=ret->getNumberOfTuples();
if (nCellDel)
_nodal_connec_index->reAlloc(nbOfCells-nCellDel+1);
computeTypes();
if(getMeshDimension()!=1)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::removeDegenerated1DCells works on umeshes with meshdim equals to 1 !");
std::size_t nbCells(getNumberOfCells()),newSize(0),newSize2(0);
- const int *conn(getNodalConnectivity()->begin()),*conni(getNodalConnectivityIndex()->begin());
+ const mcIdType *conn(getNodalConnectivity()->begin()),*conni(getNodalConnectivityIndex()->begin());
{
for(std::size_t i=0;i<nbCells;i++)
{
}
if(newSize==nbCells)//no cells has been removed -> do nothing
return false;
- MCAuto<DataArrayInt> newConn(DataArrayInt::New()),newConnI(DataArrayInt::New()); newConnI->alloc(newSize+1,1); newConn->alloc(newSize2,1);
- int *newConnPtr(newConn->getPointer()),*newConnIPtr(newConnI->getPointer()); newConnIPtr[0]=0;
+ MCAuto<DataArrayIdType> newConn(DataArrayIdType::New()),newConnI(DataArrayIdType::New()); newConnI->alloc(newSize+1,1); newConn->alloc(newSize2,1);
+ mcIdType *newConnPtr(newConn->getPointer()),*newConnIPtr(newConnI->getPointer()); newConnIPtr[0]=0;
for(std::size_t i=0;i<nbCells;i++)
{
if(conn[conni[i]+1]!=conn[conni[i]+2])
* A cell is considered to be oriented correctly if an angle between its
* normal vector and a given vector is less than \c PI / \c 2.
* \param [in] vec - 3 components of the vector specifying the correct orientation of
- * cells.
+ * cells.
* \param [in] polyOnly - if \c true, only polygons are checked, else, all cells are
* checked.
* \param [in,out] cells - a vector returning ids of incorrectly oriented cells. It
* \ref py_mcumesh_are2DCellsNotCorrectlyOriented "Here is a Python example".
* \endif
*/
-void MEDCouplingUMesh::are2DCellsNotCorrectlyOriented(const double *vec, bool polyOnly, std::vector<int>& cells) const
+void MEDCouplingUMesh::are2DCellsNotCorrectlyOriented(const double *vec, bool polyOnly, std::vector<mcIdType>& cells) const
{
if(getMeshDimension()!=2 || getSpaceDimension()!=3)
throw INTERP_KERNEL::Exception("Invalid mesh to apply are2DCellsNotCorrectlyOriented on it : must be meshDim==2 and spaceDim==3 !");
- int nbOfCells=getNumberOfCells();
- const int *conn=_nodal_connec->begin();
- const int *connI=_nodal_connec_index->begin();
+ mcIdType nbOfCells=getNumberOfCells();
+ const mcIdType *conn=_nodal_connec->begin();
+ const mcIdType *connI=_nodal_connec_index->begin();
const double *coordsPtr=_coords->begin();
- for(int i=0;i<nbOfCells;i++)
+ for(mcIdType i=0;i<nbOfCells;i++)
{
INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)conn[connI[i]];
if(!polyOnly || (type==INTERP_KERNEL::NORM_POLYGON || type==INTERP_KERNEL::NORM_QPOLYG))
/*!
* Reverse connectivity of 2D cells whose orientation is not correct. A cell is
* considered to be oriented correctly if an angle between its normal vector and a
- * given vector is less than \c PI / \c 2.
+ * given vector is less than \c PI / \c 2.
* \param [in] vec - 3 components of the vector specifying the correct orientation of
- * cells.
+ * cells.
* \param [in] polyOnly - if \c true, only polygons are checked, else, all cells are
* checked.
* \throw If \a this->getMeshDimension() != 2.
{
if(getMeshDimension()!=2 || getSpaceDimension()!=3)
throw INTERP_KERNEL::Exception("Invalid mesh to apply orientCorrectly2DCells on it : must be meshDim==2 and spaceDim==3 !");
- int nbOfCells(getNumberOfCells()),*conn(_nodal_connec->getPointer());
- const int *connI(_nodal_connec_index->begin());
+ mcIdType nbOfCells=getNumberOfCells();
+ mcIdType *conn(_nodal_connec->getPointer());
+ const mcIdType *connI(_nodal_connec_index->begin());
const double *coordsPtr(_coords->begin());
bool isModified(false);
- for(int i=0;i<nbOfCells;i++)
+ for(mcIdType i=0;i<nbOfCells;i++)
{
INTERP_KERNEL::NormalizedCellType type((INTERP_KERNEL::NormalizedCellType)conn[connI[i]]);
if(!polyOnly || (type==INTERP_KERNEL::NORM_POLYGON || type==INTERP_KERNEL::NORM_QPOLYG))
int mdim(getMeshDimension());
if(mdim!=2 && mdim!=1)
throw INTERP_KERNEL::Exception("Invalid mesh to apply changeOrientationOfCells on it : must be meshDim==2 or meshDim==1 !");
- int nbOfCells(getNumberOfCells()),*conn(_nodal_connec->getPointer());
- const int *connI(_nodal_connec_index->begin());
+ mcIdType nbOfCells=getNumberOfCells();
+ mcIdType *conn(_nodal_connec->getPointer());
+ const mcIdType *connI(_nodal_connec_index->begin());
if(mdim==2)
{//2D
- for(int i=0;i<nbOfCells;i++)
+ for(mcIdType i=0;i<nbOfCells;i++)
{
INTERP_KERNEL::NormalizedCellType type((INTERP_KERNEL::NormalizedCellType)conn[connI[i]]);
const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel(type));
}
else
{//1D
- for(int i=0;i<nbOfCells;i++)
+ for(mcIdType i=0;i<nbOfCells;i++)
{
INTERP_KERNEL::NormalizedCellType type((INTERP_KERNEL::NormalizedCellType)conn[connI[i]]);
const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel(type));
* \ref py_mcumesh_arePolyhedronsNotCorrectlyOriented "Here is a Python example".
* \endif
*/
-void MEDCouplingUMesh::arePolyhedronsNotCorrectlyOriented(std::vector<int>& cells) const
+void MEDCouplingUMesh::arePolyhedronsNotCorrectlyOriented(std::vector<mcIdType>& cells) const
{
if(getMeshDimension()!=3 || getSpaceDimension()!=3)
throw INTERP_KERNEL::Exception("Invalid mesh to apply arePolyhedronsNotCorrectlyOriented on it : must be meshDim==3 and spaceDim==3 !");
- int nbOfCells=getNumberOfCells();
- const int *conn=_nodal_connec->begin();
- const int *connI=_nodal_connec_index->begin();
+ mcIdType nbOfCells=getNumberOfCells();
+ const mcIdType *conn=_nodal_connec->begin();
+ const mcIdType *connI=_nodal_connec_index->begin();
const double *coordsPtr=_coords->begin();
- for(int i=0;i<nbOfCells;i++)
+ for(mcIdType i=0;i<nbOfCells;i++)
{
INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)conn[connI[i]];
if(type==INTERP_KERNEL::NORM_POLYHED)
/*!
* Tries to fix connectivity of polyhedra, so that normal vector of all facets to point
- * out of the cell.
+ * out of the cell.
* \throw If \a this->getMeshDimension() != 3.
* \throw If \a this->getSpaceDimension() != 3.
* \throw If the coordinates array is not set.
{
if(getMeshDimension()!=3 || getSpaceDimension()!=3)
throw INTERP_KERNEL::Exception("Invalid mesh to apply orientCorrectlyPolyhedrons on it : must be meshDim==3 and spaceDim==3 !");
- int nbOfCells=getNumberOfCells();
- int *conn=_nodal_connec->getPointer();
- const int *connI=_nodal_connec_index->begin();
+ mcIdType nbOfCells=getNumberOfCells();
+ mcIdType *conn=_nodal_connec->getPointer();
+ const mcIdType *connI=_nodal_connec_index->begin();
const double *coordsPtr=_coords->begin();
- for(int i=0;i<nbOfCells;i++)
+ for(mcIdType i=0;i<nbOfCells;i++)
{
INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)conn[connI[i]];
if(type==INTERP_KERNEL::NORM_POLYHED)
}
/*!
- * This method invert orientation of all cells in \a this.
+ * This method invert orientation of all cells in \a this.
* After calling this method the absolute value of measure of cells in \a this are the same than before calling.
* This method only operates on the connectivity so coordinates are not touched at all.
*/
{
checkConnectivityFullyDefined();
std::set<INTERP_KERNEL::NormalizedCellType> gts(getAllGeoTypes());
- int *conn(_nodal_connec->getPointer());
- const int *conni(_nodal_connec_index->begin());
+ mcIdType *conn(_nodal_connec->getPointer());
+ const mcIdType *conni(_nodal_connec_index->begin());
for(std::set<INTERP_KERNEL::NormalizedCellType>::const_iterator gt=gts.begin();gt!=gts.end();gt++)
{
INTERP_KERNEL::AutoCppPtr<INTERP_KERNEL::OrientationInverter> oi(INTERP_KERNEL::OrientationInverter::BuildInstanceFrom(*gt));
- MCAuto<DataArrayInt> cwt(giveCellsWithType(*gt));
- for(const int *it=cwt->begin();it!=cwt->end();it++)
+ MCAuto<DataArrayIdType> cwt(giveCellsWithType(*gt));
+ for(const mcIdType *it=cwt->begin();it!=cwt->end();it++)
oi->operate(conn+conni[*it]+1,conn+conni[*it+1]);
}
updateTime();
* INTERP_KERNEL::NORM_PENTA6, INTERP_KERNEL::NORM_HEXGP12 etc) to respect the MED convention
* according to which the first facet of the cell should be oriented to have the normal vector
* pointing out of cell.
- * \return DataArrayInt * - a new instance of DataArrayInt holding ids of fixed
+ * \return DataArrayIdType * - a new instance of DataArrayIdType holding ids of fixed
* cells. The caller is to delete this array using decrRef() as it is no more
- * needed.
+ * needed.
* \throw If \a this->getMeshDimension() != 3.
* \throw If \a this->getSpaceDimension() != 3.
* \throw If the coordinates array is not set.
* \endif
* \sa MEDCouplingUMesh::findAndCorrectBadOriented3DCells
*/
-DataArrayInt *MEDCouplingUMesh::findAndCorrectBadOriented3DExtrudedCells()
+DataArrayIdType *MEDCouplingUMesh::findAndCorrectBadOriented3DExtrudedCells()
{
const char msg[]="check3DCellsWellOriented detection works only for 3D cells !";
if(getMeshDimension()!=3)
if(spaceDim!=3)
throw INTERP_KERNEL::Exception(msg);
//
- int nbOfCells=getNumberOfCells();
- int *conn=_nodal_connec->getPointer();
- const int *connI=_nodal_connec_index->begin();
+ mcIdType nbOfCells=getNumberOfCells();
+ mcIdType *conn=_nodal_connec->getPointer();
+ const mcIdType *connI=_nodal_connec_index->begin();
const double *coo=getCoords()->begin();
- MCAuto<DataArrayInt> cells(DataArrayInt::New()); cells->alloc(0,1);
- for(int i=0;i<nbOfCells;i++)
+ MCAuto<DataArrayIdType> cells(DataArrayIdType::New()); cells->alloc(0,1);
+ for(mcIdType i=0;i<nbOfCells;i++)
{
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel((INTERP_KERNEL::NormalizedCellType)conn[connI[i]]);
if(cm.isExtruded() && !cm.isDynamic() && !cm.isQuadratic())
* This method is a faster method to correct orientation of all 3D cells in \a this.
* This method works only if \a this is a 3D mesh, that is to say a mesh with mesh dimension 3 and a space dimension 3.
* This method makes the hypothesis that \a this a coherent that is to say MEDCouplingUMesh::checkConsistency should throw no exception.
- *
- * \return a newly allocated int array with one components containing cell ids renumbered to fit the convention of MED (MED file and MEDCoupling)
- * \sa MEDCouplingUMesh::orientCorrectlyPolyhedrons,
+ *
+ * \return a newly allocated mcIdType array with one components containing cell ids renumbered to fit the convention of MED (MED file and MEDCoupling)
+ * \sa MEDCouplingUMesh::orientCorrectlyPolyhedrons,
*/
-DataArrayInt *MEDCouplingUMesh::findAndCorrectBadOriented3DCells()
+DataArrayIdType *MEDCouplingUMesh::findAndCorrectBadOriented3DCells()
{
if(getMeshDimension()!=3 || getSpaceDimension()!=3)
throw INTERP_KERNEL::Exception("Invalid mesh to apply findAndCorrectBadOriented3DCells on it : must be meshDim==3 and spaceDim==3 !");
- int nbOfCells=getNumberOfCells();
- int *conn=_nodal_connec->getPointer();
- const int *connI=_nodal_connec_index->begin();
+ mcIdType nbOfCells=getNumberOfCells();
+ mcIdType *conn=_nodal_connec->getPointer();
+ const mcIdType *connI=_nodal_connec_index->begin();
const double *coordsPtr=_coords->begin();
- MCAuto<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(0,1);
- for(int i=0;i<nbOfCells;i++)
+ MCAuto<DataArrayIdType> ret=DataArrayIdType::New(); ret->alloc(0,1);
+ for(mcIdType i=0;i<nbOfCells;i++)
{
INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)conn[connI[i]];
switch(type)
{
if(getMeshDimension()!=2 || getSpaceDimension()!=3)
throw INTERP_KERNEL::Exception("Invalid mesh to apply getFastAveragePlaneOfThis on it : must be meshDim==2 and spaceDim==3 !");
- const int *conn=_nodal_connec->begin();
- const int *connI=_nodal_connec_index->begin();
+ const mcIdType *conn=_nodal_connec->begin();
+ const mcIdType *connI=_nodal_connec_index->begin();
const double *coordsPtr=_coords->begin();
- INTERP_KERNEL::areaVectorOfPolygon<int,INTERP_KERNEL::ALL_C_MODE>(conn+1,connI[1]-connI[0]-1,coordsPtr,vec);
+ INTERP_KERNEL::areaVectorOfPolygon<mcIdType,INTERP_KERNEL::ALL_C_MODE>(conn+1,connI[1]-connI[0]-1,coordsPtr,vec);
std::copy(coordsPtr+3*conn[1],coordsPtr+3*conn[1]+3,pos);
}
* INTERP_KERNEL::NORM_TRI3, INTERP_KERNEL::NORM_QUAD4 and INTERP_KERNEL::NORM_TETRA4.
* For a cell of other type an exception is thrown.
* Space dimension of a 2D mesh can be either 2 or 3.
- * The Edge Ratio of a cell \f$t\f$ is:
+ * The Edge Ratio of a cell \f$t\f$ is:
* \f$\frac{|t|_\infty}{|t|_0}\f$,
* where \f$|t|_\infty\f$ and \f$|t|_0\f$ respectively denote the greatest and
* the smallest edge lengths of \f$t\f$.
* \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble on
* cells and one time, lying on \a this mesh. The caller is to delete this
- * field using decrRef() as it is no more needed.
+ * field using decrRef() as it is no more needed.
* \throw If the coordinates array is not set.
* \throw If \a this mesh contains elements of dimension different from the mesh dimension.
* \throw If the connectivity data array has more than one component.
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::getEdgeRatioField : MeshDimension must be equal to 2 or 3 !");
MCAuto<MEDCouplingFieldDouble> ret=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
ret->setMesh(this);
- int nbOfCells=getNumberOfCells();
+ mcIdType nbOfCells=getNumberOfCells();
MCAuto<DataArrayDouble> arr=DataArrayDouble::New();
arr->alloc(nbOfCells,1);
double *pt=arr->getPointer();
ret->setArray(arr);//In case of throw to avoid mem leaks arr will be used after decrRef.
- const int *conn=_nodal_connec->begin();
- const int *connI=_nodal_connec_index->begin();
+ const mcIdType *conn=_nodal_connec->begin();
+ const mcIdType *connI=_nodal_connec_index->begin();
const double *coo=_coords->begin();
double tmp[12];
- for(int i=0;i<nbOfCells;i++,pt++)
+ for(mcIdType i=0;i<nbOfCells;i++,pt++)
{
INTERP_KERNEL::NormalizedCellType t=(INTERP_KERNEL::NormalizedCellType)*conn;
switch(t)
* Space dimension of a 2D mesh can be either 2 or 3.
* \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble on
* cells and one time, lying on \a this mesh. The caller is to delete this
- * field using decrRef() as it is no more needed.
+ * field using decrRef() as it is no more needed.
* \throw If the coordinates array is not set.
* \throw If \a this mesh contains elements of dimension different from the mesh dimension.
* \throw If the connectivity data array has more than one component.
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::getAspectRatioField : MeshDimension must be equal to 2 or 3 !");
MCAuto<MEDCouplingFieldDouble> ret=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
ret->setMesh(this);
- int nbOfCells=getNumberOfCells();
+ mcIdType nbOfCells=getNumberOfCells();
MCAuto<DataArrayDouble> arr=DataArrayDouble::New();
arr->alloc(nbOfCells,1);
double *pt=arr->getPointer();
ret->setArray(arr);//In case of throw to avoid mem leaks arr will be used after decrRef.
- const int *conn=_nodal_connec->begin();
- const int *connI=_nodal_connec_index->begin();
+ const mcIdType *conn=_nodal_connec->begin();
+ const mcIdType *connI=_nodal_connec_index->begin();
const double *coo=_coords->begin();
double tmp[12];
- for(int i=0;i<nbOfCells;i++,pt++)
+ for(mcIdType i=0;i<nbOfCells;i++,pt++)
{
INTERP_KERNEL::NormalizedCellType t=(INTERP_KERNEL::NormalizedCellType)*conn;
switch(t)
* \f]
* \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble on
* cells and one time, lying on \a this mesh. The caller is to delete this
- * field using decrRef() as it is no more needed.
+ * field using decrRef() as it is no more needed.
* \throw If the coordinates array is not set.
* \throw If \a this mesh contains elements of dimension different from the mesh dimension.
* \throw If the connectivity data array has more than one component.
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::getWarpField : MeshDimension must be equal to 2 !");
MCAuto<MEDCouplingFieldDouble> ret=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
ret->setMesh(this);
- int nbOfCells=getNumberOfCells();
+ mcIdType nbOfCells=getNumberOfCells();
MCAuto<DataArrayDouble> arr=DataArrayDouble::New();
arr->alloc(nbOfCells,1);
double *pt=arr->getPointer();
ret->setArray(arr);//In case of throw to avoid mem leaks arr will be used after decrRef.
- const int *conn=_nodal_connec->begin();
- const int *connI=_nodal_connec_index->begin();
+ const mcIdType *conn=_nodal_connec->begin();
+ const mcIdType *connI=_nodal_connec_index->begin();
const double *coo=_coords->begin();
double tmp[12];
- for(int i=0;i<nbOfCells;i++,pt++)
+ for(mcIdType i=0;i<nbOfCells;i++,pt++)
{
INTERP_KERNEL::NormalizedCellType t=(INTERP_KERNEL::NormalizedCellType)*conn;
switch(t)
* For a cell of other type an exception is thrown.
* \return MEDCouplingFieldDouble * - a new instance of MEDCouplingFieldDouble on
* cells and one time, lying on \a this mesh. The caller is to delete this
- * field using decrRef() as it is no more needed.
+ * field using decrRef() as it is no more needed.
* \throw If the coordinates array is not set.
* \throw If \a this mesh contains elements of dimension different from the mesh dimension.
* \throw If the connectivity data array has more than one component.
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::getSkewField : MeshDimension must be equal to 2 !");
MCAuto<MEDCouplingFieldDouble> ret=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
ret->setMesh(this);
- int nbOfCells=getNumberOfCells();
+ mcIdType nbOfCells=getNumberOfCells();
MCAuto<DataArrayDouble> arr=DataArrayDouble::New();
arr->alloc(nbOfCells,1);
double *pt=arr->getPointer();
ret->setArray(arr);//In case of throw to avoid mem leaks arr will be used after decrRef.
- const int *conn=_nodal_connec->begin();
- const int *connI=_nodal_connec_index->begin();
+ const mcIdType *conn=_nodal_connec->begin();
+ const mcIdType *connI=_nodal_connec_index->begin();
const double *coo=_coords->begin();
double tmp[12];
- for(int i=0;i<nbOfCells;i++,pt++)
+ for(mcIdType i=0;i<nbOfCells;i++,pt++)
{
INTERP_KERNEL::NormalizedCellType t=(INTERP_KERNEL::NormalizedCellType)*conn;
switch(t)
ret->setMesh(this);
std::set<INTERP_KERNEL::NormalizedCellType> types;
ComputeAllTypesInternal(types,_nodal_connec,_nodal_connec_index);
- int spaceDim(getSpaceDimension()),nbCells(getNumberOfCells());
+ int spaceDim(getSpaceDimension());
+ mcIdType nbCells(getNumberOfCells());
MCAuto<DataArrayDouble> arr(DataArrayDouble::New());
arr->alloc(nbCells,1);
for(std::set<INTERP_KERNEL::NormalizedCellType>::const_iterator it=types.begin();it!=types.end();it++)
{
INTERP_KERNEL::AutoCppPtr<INTERP_KERNEL::DiameterCalculator> dc(INTERP_KERNEL::CellModel::GetCellModel(*it).buildInstanceOfDiameterCalulator(spaceDim));
- MCAuto<DataArrayInt> cellIds(giveCellsWithType(*it));
+ MCAuto<DataArrayIdType> cellIds(giveCellsWithType(*it));
dc->computeForListOfCellIdsUMeshFrmt(cellIds->begin(),cellIds->end(),_nodal_connec_index->begin(),_nodal_connec->begin(),getCoords()->begin(),arr->getPointer());
}
ret->setArray(arr);
/*!
* This method aggregate the bbox of each cell and put it into bbox parameter (xmin,xmax,ymin,ymax,zmin,zmax).
- *
+ *
* \param [in] arcDetEps - a parameter specifying in case of 2D quadratic polygon cell the detection limit between linear and arc circle. (By default 1e-12)
* For all other cases this input parameter is ignored.
* \return DataArrayDouble * - newly created object (to be managed by the caller) \a this number of cells tuples and 2*spacedim components.
- *
+ *
* \throw If \a this is not fully set (coordinates and connectivity).
* \throw If a cell in \a this has no valid nodeId.
* \sa MEDCouplingUMesh::getBoundingBoxForBBTreeFast, MEDCouplingUMesh::getBoundingBoxForBBTree2DQuadratic
/*!
* This method aggregate the bbox of each cell only considering the nodes constituting each cell and put it into bbox parameter.
* So meshes having quadratic cells the computed bounding boxes can be invalid !
- *
+ *
* \return DataArrayDouble * - newly created object (to be managed by the caller) \a this number of cells tuples and 2*spacedim components.
- *
+ *
* \throw If \a this is not fully set (coordinates and connectivity).
* \throw If a cell in \a this has no valid nodeId.
*/
DataArrayDouble *MEDCouplingUMesh::getBoundingBoxForBBTreeFast() const
{
checkFullyDefined();
- int spaceDim(getSpaceDimension()),nbOfCells(getNumberOfCells()),nbOfNodes(getNumberOfNodes());
+ int spaceDim(getSpaceDimension());
+ mcIdType nbOfCells(getNumberOfCells()), nbOfNodes(getNumberOfNodes());
MCAuto<DataArrayDouble> ret(DataArrayDouble::New()); ret->alloc(nbOfCells,2*spaceDim);
double *bbox(ret->getPointer());
- for(int i=0;i<nbOfCells*spaceDim;i++)
+ for(mcIdType i=0;i<nbOfCells*spaceDim;i++)
{
bbox[2*i]=std::numeric_limits<double>::max();
bbox[2*i+1]=-std::numeric_limits<double>::max();
}
const double *coordsPtr(_coords->begin());
- const int *conn(_nodal_connec->begin()),*connI(_nodal_connec_index->begin());
- for(int i=0;i<nbOfCells;i++)
+ const mcIdType *conn(_nodal_connec->begin()),*connI(_nodal_connec_index->begin());
+ for(mcIdType i=0;i<nbOfCells;i++)
{
- int offset=connI[i]+1;
- int nbOfNodesForCell(connI[i+1]-offset),kk(0);
- for(int j=0;j<nbOfNodesForCell;j++)
+ mcIdType offset=connI[i]+1;
+ mcIdType nbOfNodesForCell(connI[i+1]-offset),kk(0);
+ for(mcIdType j=0;j<nbOfNodesForCell;j++)
{
- int nodeId=conn[offset+j];
+ mcIdType nodeId=conn[offset+j];
if(nodeId>=0 && nodeId<nbOfNodes)
{
for(int k=0;k<spaceDim;k++)
* useful for 2D meshes having quadratic cells
* because for this type of cells getBoundingBoxForBBTreeFast method may return invalid bounding boxes (since it just considers
* the two extremities of the arc of circle).
- *
+ *
* \param [in] arcDetEps - a parameter specifying in case of 2D quadratic polygon cell the detection limit between linear and arc circle. (By default 1e-12)
* \return DataArrayDouble * - newly created object (to be managed by the caller) \a this number of cells tuples and 2*spacedim components.
* \throw If \a this is not fully defined.
checkFullyDefined();
INTERP_KERNEL::QuadraticPlanarPrecision arcPrec(arcDetEps);
- int spaceDim(getSpaceDimension()),mDim(getMeshDimension()),nbOfCells(getNumberOfCells());
+ int spaceDim(getSpaceDimension()),mDim(getMeshDimension());
+ mcIdType nbOfCells=getNumberOfCells();
if(spaceDim!=2 || mDim!=2)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::getBoundingBoxForBBTree2DQuadratic : This method should be applied on mesh with mesh dimension equal to 2 and space dimension also equal to 2!");
MCAuto<DataArrayDouble> ret(DataArrayDouble::New()); ret->alloc(nbOfCells,2*spaceDim);
double *bbox(ret->getPointer());
const double *coords(_coords->begin());
- const int *conn(_nodal_connec->begin()),*connI(_nodal_connec_index->begin());
- for(int i=0;i<nbOfCells;i++,bbox+=4,connI++)
+ const mcIdType *conn(_nodal_connec->begin()),*connI(_nodal_connec_index->begin());
+ for(mcIdType i=0;i<nbOfCells;i++,bbox+=4,connI++)
{
const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel((INTERP_KERNEL::NormalizedCellType)conn[*connI]));
- int sz(connI[1]-connI[0]-1);
+ mcIdType sz(connI[1]-connI[0]-1);
std::vector<INTERP_KERNEL::Node *> nodes(sz);
INTERP_KERNEL::QuadraticPolygon *pol(0);
- for(int j=0;j<sz;j++)
+ for(mcIdType j=0;j<sz;j++)
{
- int nodeId(conn[*connI+1+j]);
+ mcIdType nodeId(conn[*connI+1+j]);
nodes[j]=new INTERP_KERNEL::Node(coords[nodeId*2],coords[nodeId*2+1]);
}
if(!cm.isQuadratic())
else
pol=INTERP_KERNEL::QuadraticPolygon::BuildArcCirclePolygon(nodes);
INTERP_KERNEL::Bounds b; b.prepareForAggregation(); pol->fillBounds(b); delete pol;
- bbox[0]=b.getXMin(); bbox[1]=b.getXMax(); bbox[2]=b.getYMin(); bbox[3]=b.getYMax();
+ bbox[0]=b.getXMin(); bbox[1]=b.getXMax(); bbox[2]=b.getYMin(); bbox[3]=b.getYMax();
}
return ret.retn();
}
* useful for 2D meshes having quadratic cells
* because for this type of cells getBoundingBoxForBBTreeFast method may return invalid bounding boxes (since it just considers
* the two extremities of the arc of circle).
- *
+ *
* \param [in] arcDetEps - a parameter specifying in case of 2D quadratic polygon cell the detection limit between linear and arc circle. (By default 1e-12)
* \return DataArrayDouble * - newly created object (to be managed by the caller) \a this number of cells tuples and 2*spacedim components.
* \throw If \a this is not fully defined.
DataArrayDouble *MEDCouplingUMesh::getBoundingBoxForBBTree1DQuadratic(double arcDetEps) const
{
checkFullyDefined();
- int spaceDim(getSpaceDimension()),mDim(getMeshDimension()),nbOfCells(getNumberOfCells());
+ int spaceDim(getSpaceDimension()),mDim(getMeshDimension());
+ mcIdType nbOfCells=getNumberOfCells();
if(spaceDim!=2 || mDim!=1)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::getBoundingBoxForBBTree1DQuadratic : This method should be applied on mesh with mesh dimension equal to 1 and space dimension also equal to 2!");
INTERP_KERNEL::QuadraticPlanarPrecision arcPrec(arcDetEps);
MCAuto<DataArrayDouble> ret(DataArrayDouble::New()); ret->alloc(nbOfCells,2*spaceDim);
double *bbox(ret->getPointer());
const double *coords(_coords->begin());
- const int *conn(_nodal_connec->begin()),*connI(_nodal_connec_index->begin());
- for(int i=0;i<nbOfCells;i++,bbox+=4,connI++)
+ const mcIdType *conn(_nodal_connec->begin()),*connI(_nodal_connec_index->begin());
+ for(mcIdType i=0;i<nbOfCells;i++,bbox+=4,connI++)
{
const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel((INTERP_KERNEL::NormalizedCellType)conn[*connI]));
- int sz(connI[1]-connI[0]-1);
+ mcIdType sz(connI[1]-connI[0]-1);
std::vector<INTERP_KERNEL::Node *> nodes(sz);
INTERP_KERNEL::Edge *edge(0);
- for(int j=0;j<sz;j++)
+ for(mcIdType j=0;j<sz;j++)
{
- int nodeId(conn[*connI+1+j]);
+ mcIdType nodeId(conn[*connI+1+j]);
nodes[j]=new INTERP_KERNEL::Node(coords[nodeId*2],coords[nodeId*2+1]);
}
if(!cm.isQuadratic())
class ConnReader
{
public:
- ConnReader(const int *c, int val):_conn(c),_val(val) { }
- bool operator() (const int& pos) { return _conn[pos]!=_val; }
+ ConnReader(const mcIdType *c, mcIdType val):_conn(c),_val(val) { }
+ bool operator() (const mcIdType& pos) { return _conn[pos]!=_val; }
private:
- const int *_conn;
- int _val;
+ const mcIdType *_conn;
+ mcIdType _val;
};
class ConnReader2
{
public:
- ConnReader2(const int *c, int val):_conn(c),_val(val) { }
- bool operator() (const int& pos) { return _conn[pos]==_val; }
+ ConnReader2(const mcIdType *c, mcIdType val):_conn(c),_val(val) { }
+ bool operator() (const mcIdType& pos) { return _conn[pos]==_val; }
private:
- const int *_conn;
- int _val;
+ const mcIdType *_conn;
+ mcIdType _val;
};
}
* This method expects that \a this is sorted by types. If not an exception will be thrown.
* This method returns in the same format as code (see MEDCouplingUMesh::checkTypeConsistencyAndContig or MEDCouplingUMesh::splitProfilePerType) how
* \a this is composed in cell types.
- * The returned array is of size 3*n where n is the number of different types present in \a this.
- * For every k in [0,n] ret[3*k+2]==-1 because it has no sense here.
+ * The returned array is of size 3*n where n is the number of different types present in \a this.
+ * For every k in [0,n] ret[3*k+2]==-1 because it has no sense here.
* This parameter is kept only for compatibility with other method listed above.
*/
-std::vector<int> MEDCouplingUMesh::getDistributionOfTypes() const
+std::vector<mcIdType> MEDCouplingUMesh::getDistributionOfTypes() const
{
checkConnectivityFullyDefined();
- const int *conn=_nodal_connec->begin();
- const int *connI=_nodal_connec_index->begin();
- const int *work=connI;
- int nbOfCells=getNumberOfCells();
+ const mcIdType *conn=_nodal_connec->begin();
+ const mcIdType *connI=_nodal_connec_index->begin();
+ const mcIdType *work=connI;
+ mcIdType nbOfCells=getNumberOfCells();
std::size_t n=getAllGeoTypes().size();
- std::vector<int> ret(3*n,-1); //ret[3*k+2]==-1 because it has no sense here
+ std::vector<mcIdType> ret(3*n,-1); //ret[3*k+2]==-1 because it has no sense here
std::set<INTERP_KERNEL::NormalizedCellType> types;
for(std::size_t i=0;work!=connI+nbOfCells;i++)
{
}
types.insert(typ);
ret[3*i]=typ;
- const int *work2=std::find_if(work+1,connI+nbOfCells,MEDCouplingImpl::ConnReader(conn,typ));
- ret[3*i+1]=(int)std::distance(work,work2);
+ const mcIdType *work2=std::find_if(work+1,connI+nbOfCells,MEDCouplingImpl::ConnReader(conn,typ));
+ ret[3*i+1]=ToIdType(std::distance(work,work2));
work=work2;
}
return ret;
* If it exists k so that 3*k geometric type is not in geometric types of this an exception will be thrown.
* If it exists k so that 3*k geometric type exists but the number of consecutive cell types does not match,
* an exception is thrown too.
- *
+ *
* If all geometric types in \a code are exactly those in \a this null pointer is returned.
- * If it exists a geometric type in \a this \b not in \a code \b no exception is thrown
- * and a DataArrayInt instance is returned that the user has the responsibility to deallocate.
+ * If it exists a geometric type in \a this \b not in \a code \b no exception is thrown
+ * and a DataArrayIdType instance is returned that the user has the responsibility to deallocate.
*/
-DataArrayInt *MEDCouplingUMesh::checkTypeConsistencyAndContig(const std::vector<int>& code, const std::vector<const DataArrayInt *>& idsPerType) const
+DataArrayIdType *MEDCouplingUMesh::checkTypeConsistencyAndContig(const std::vector<mcIdType>& code, const std::vector<const DataArrayIdType *>& idsPerType) const
{
if(code.empty())
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::checkTypeConsistencyAndContig : code is empty, should not !");
if(sz%3!=0)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::checkTypeConsistencyAndContig : code size is NOT %3 !");
std::vector<INTERP_KERNEL::NormalizedCellType> types;
- int nb=0;
+ mcIdType nb=0;
bool isNoPflUsed=true;
for(std::size_t i=0;i<n;i++)
if(std::find(types.begin(),types.end(),(INTERP_KERNEL::NormalizedCellType)code[3*i])==types.end())
if(types.size()==_types.size())
return 0;
}
- MCAuto<DataArrayInt> ret=DataArrayInt::New();
+ MCAuto<DataArrayIdType> ret=DataArrayIdType::New();
ret->alloc(nb,1);
- int *retPtr=ret->getPointer();
- const int *connI=_nodal_connec_index->begin();
- const int *conn=_nodal_connec->begin();
- int nbOfCells=getNumberOfCells();
- const int *i=connI;
+ mcIdType *retPtr=ret->getPointer();
+ const mcIdType *connI=_nodal_connec_index->begin();
+ const mcIdType *conn=_nodal_connec->begin();
+ mcIdType nbOfCells=getNumberOfCells();
+ const mcIdType *i=connI;
int kk=0;
for(std::vector<INTERP_KERNEL::NormalizedCellType>::const_iterator it=types.begin();it!=types.end();it++,kk++)
{
- i=std::find_if(i,connI+nbOfCells,MEDCouplingImpl::ConnReader2(conn,(int)(*it)));
- int offset=(int)std::distance(connI,i);
- const int *j=std::find_if(i+1,connI+nbOfCells,MEDCouplingImpl::ConnReader(conn,(int)(*it)));
- int nbOfCellsOfCurType=(int)std::distance(i,j);
+ i=std::find_if(i,connI+nbOfCells,MEDCouplingImpl::ConnReader2(conn,ToIdType((*it))));
+ mcIdType offset=ToIdType(std::distance(connI,i));
+ const mcIdType *j=std::find_if(i+1,connI+nbOfCells,MEDCouplingImpl::ConnReader(conn,ToIdType((*it))));
+ mcIdType nbOfCellsOfCurType=ToIdType(std::distance(i,j));
if(code[3*kk+2]==-1)
- for(int k=0;k<nbOfCellsOfCurType;k++)
+ for(mcIdType k=0;k<nbOfCellsOfCurType;k++)
*retPtr++=k+offset;
else
{
- int idInIdsPerType=code[3*kk+2];
- if(idInIdsPerType>=0 && idInIdsPerType<(int)idsPerType.size())
+ mcIdType idInIdsPerType=code[3*kk+2];
+ if(idInIdsPerType>=0 && idInIdsPerType<ToIdType(idsPerType.size()))
{
- const DataArrayInt *zePfl=idsPerType[idInIdsPerType];
+ const DataArrayIdType *zePfl=idsPerType[idInIdsPerType];
if(zePfl)
{
zePfl->checkAllocated();
if(zePfl->getNumberOfComponents()==1)
{
- for(const int *k=zePfl->begin();k!=zePfl->end();k++,retPtr++)
+ for(const mcIdType *k=zePfl->begin();k!=zePfl->end();k++,retPtr++)
{
if(*k>=0 && *k<nbOfCellsOfCurType)
*retPtr=(*k)+offset;
* This method is the opposite of MEDCouplingUMesh::checkTypeConsistencyAndContig method. Given a list of cells in \a profile it returns a list of sub-profiles sorted by geo type.
* The result is put in the array \a idsPerType. In the returned parameter \a code, foreach i \a code[3*i+2] refers (if different from -1) to a location into the \a idsPerType.
* This method has 1 input \a profile and 3 outputs \a code \a idsInPflPerType and \a idsPerType.
- *
+ *
* \param [in] profile
* \param [out] code is a vector of size 3*n where n is the number of different geometric type in \a this \b reduced to the profile \a profile. \a code has exactly the same semantic than in MEDCouplingUMesh::checkTypeConsistencyAndContig method.
* \param [out] idsInPflPerType is a vector of size of different geometric type in the subpart defined by \a profile of \a this ( equal to \a code.size()/3). For each i,
* This vector can be empty in case of all geometric type cells are fully covered in ascending in the given input \a profile.
* \throw if \a profile has not exactly one component. It throws too, if \a profile contains some values not in [0,getNumberOfCells()) or if \a this is not fully defined
*/
-void MEDCouplingUMesh::splitProfilePerType(const DataArrayInt *profile, std::vector<int>& code, std::vector<DataArrayInt *>& idsInPflPerType, std::vector<DataArrayInt *>& idsPerType, bool smartPflKiller) const
+void MEDCouplingUMesh::splitProfilePerType(const DataArrayIdType *profile, std::vector<mcIdType>& code, std::vector<DataArrayIdType *>& idsInPflPerType, std::vector<DataArrayIdType *>& idsPerType, bool smartPflKiller) const
{
if(!profile)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::splitProfilePerType : input profile is NULL !");
if(profile->getNumberOfComponents()!=1)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::splitProfilePerType : input profile should have exactly one component !");
checkConnectivityFullyDefined();
- const int *conn=_nodal_connec->begin();
- const int *connI=_nodal_connec_index->begin();
- int nbOfCells=getNumberOfCells();
+ const mcIdType *conn=_nodal_connec->begin();
+ const mcIdType *connI=_nodal_connec_index->begin();
+ mcIdType nbOfCells=getNumberOfCells();
std::vector<INTERP_KERNEL::NormalizedCellType> types;
- std::vector<int> typeRangeVals(1);
- for(const int *i=connI;i!=connI+nbOfCells;)
+ std::vector<mcIdType> typeRangeVals(1);
+ for(const mcIdType *i=connI;i!=connI+nbOfCells;)
{
INTERP_KERNEL::NormalizedCellType curType=(INTERP_KERNEL::NormalizedCellType)conn[*i];
if(std::find(types.begin(),types.end(),curType)!=types.end())
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::splitProfilePerType : current mesh is not sorted by type !");
}
types.push_back(curType);
- i=std::find_if(i+1,connI+nbOfCells,MEDCouplingImpl::ConnReader(conn,(int)curType));
- typeRangeVals.push_back((int)std::distance(connI,i));
+ i=std::find_if(i+1,connI+nbOfCells,MEDCouplingImpl::ConnReader(conn,ToIdType(curType)));
+ typeRangeVals.push_back(ToIdType(std::distance(connI,i)));
}
//
- DataArrayInt *castArr=0,*rankInsideCast=0,*castsPresent=0;
+ DataArrayIdType *castArr=0,*rankInsideCast=0,*castsPresent=0;
profile->splitByValueRange(&typeRangeVals[0],&typeRangeVals[0]+typeRangeVals.size(),castArr,rankInsideCast,castsPresent);
- MCAuto<DataArrayInt> tmp0=castArr;
- MCAuto<DataArrayInt> tmp1=rankInsideCast;
- MCAuto<DataArrayInt> tmp2=castsPresent;
+ MCAuto<DataArrayIdType> tmp0=castArr;
+ MCAuto<DataArrayIdType> tmp1=rankInsideCast;
+ MCAuto<DataArrayIdType> tmp2=castsPresent;
//
- int nbOfCastsFinal=castsPresent->getNumberOfTuples();
+ mcIdType nbOfCastsFinal=castsPresent->getNumberOfTuples();
code.resize(3*nbOfCastsFinal);
- std::vector< MCAuto<DataArrayInt> > idsInPflPerType2;
- std::vector< MCAuto<DataArrayInt> > idsPerType2;
- for(int i=0;i<nbOfCastsFinal;i++)
+ std::vector< MCAuto<DataArrayIdType> > idsInPflPerType2;
+ std::vector< MCAuto<DataArrayIdType> > idsPerType2;
+ for(mcIdType i=0;i<nbOfCastsFinal;i++)
{
- int castId=castsPresent->getIJ(i,0);
- MCAuto<DataArrayInt> tmp3=castArr->findIdsEqual(castId);
+ mcIdType castId=castsPresent->getIJ(i,0);
+ MCAuto<DataArrayIdType> tmp3=castArr->findIdsEqual(castId);
idsInPflPerType2.push_back(tmp3);
- code[3*i]=(int)types[castId];
+ code[3*i]=ToIdType(types[castId]);
code[3*i+1]=tmp3->getNumberOfTuples();
- MCAuto<DataArrayInt> tmp4=rankInsideCast->selectByTupleId(tmp3->begin(),tmp3->begin()+tmp3->getNumberOfTuples());
+ MCAuto<DataArrayIdType> tmp4=rankInsideCast->selectByTupleId(tmp3->begin(),tmp3->begin()+tmp3->getNumberOfTuples());
if(!smartPflKiller || !tmp4->isIota(typeRangeVals[castId+1]-typeRangeVals[castId]))
{
tmp4->copyStringInfoFrom(*profile);
idsPerType2.push_back(tmp4);
- code[3*i+2]=(int)idsPerType2.size()-1;
+ code[3*i+2]=ToIdType(idsPerType2.size())-1;
}
else
{
idsInPflPerType.resize(sz2);
for(std::size_t i=0;i<sz2;i++)
{
- DataArrayInt *locDa=idsInPflPerType2[i];
+ DataArrayIdType *locDa=idsInPflPerType2[i];
locDa->incrRef();
idsInPflPerType[i]=locDa;
}
idsPerType.resize(sz);
for(std::size_t i=0;i<sz;i++)
{
- DataArrayInt *locDa=idsPerType2[i];
+ DataArrayIdType *locDa=idsPerType2[i];
locDa->incrRef();
idsPerType[i]=locDa;
}
* The following equality should be verified 'nM1LevMesh->getMeshDimension()==this->getMeshDimension()-1'
* This method returns 5+2 elements. 'desc', 'descIndx', 'revDesc', 'revDescIndx' and 'meshnM1' behaves exactly as MEDCoupling::MEDCouplingUMesh::buildDescendingConnectivity except the content as described after. The returned array specifies the n-1 mesh reordered by type as MEDMEM does. 'nM1LevMeshIds' contains the ids in returned 'meshnM1'. Finally 'meshnM1Old2New' contains numbering old2new that is to say the cell #k in coarse 'nM1LevMesh' will have the number ret[k] in returned mesh 'nM1LevMesh' MEDMEM reordered.
*/
-MEDCouplingUMesh *MEDCouplingUMesh::emulateMEDMEMBDC(const MEDCouplingUMesh *nM1LevMesh, DataArrayInt *desc, DataArrayInt *descIndx, DataArrayInt *&revDesc, DataArrayInt *&revDescIndx, DataArrayInt *& nM1LevMeshIds, DataArrayInt *&meshnM1Old2New) const
+MEDCouplingUMesh *MEDCouplingUMesh::emulateMEDMEMBDC(const MEDCouplingUMesh *nM1LevMesh, DataArrayIdType *desc, DataArrayIdType *descIndx, DataArrayIdType *&revDesc, DataArrayIdType *&revDescIndx, DataArrayIdType *& nM1LevMeshIds, DataArrayIdType *&meshnM1Old2New) const
{
checkFullyDefined();
nM1LevMesh->checkFullyDefined();
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::emulateMEDMEMBDC : The mesh passed as first argument should have a meshDim equal to this->getMeshDimension()-1 !" );
if(_coords!=nM1LevMesh->getCoords())
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::emulateMEDMEMBDC : 'this' and mesh in first argument should share the same coords : Use tryToShareSameCoords method !");
- MCAuto<DataArrayInt> tmp0=DataArrayInt::New();
- MCAuto<DataArrayInt> tmp1=DataArrayInt::New();
+ MCAuto<DataArrayIdType> tmp0=DataArrayIdType::New();
+ MCAuto<DataArrayIdType> tmp1=DataArrayIdType::New();
MCAuto<MEDCouplingUMesh> ret1=buildDescendingConnectivity(desc,descIndx,tmp0,tmp1);
- MCAuto<DataArrayInt> ret0=ret1->sortCellsInMEDFileFrmt();
+ MCAuto<DataArrayIdType> ret0=ret1->sortCellsInMEDFileFrmt();
desc->transformWithIndArr(ret0->begin(),ret0->begin()+ret0->getNbOfElems());
MCAuto<MEDCouplingUMesh> tmp=MEDCouplingUMesh::New();
tmp->setConnectivity(tmp0,tmp1);
tmp->renumberCells(ret0->begin(),false);
revDesc=tmp->getNodalConnectivity();
revDescIndx=tmp->getNodalConnectivityIndex();
- DataArrayInt *ret=0;
+ DataArrayIdType *ret=0;
if(!ret1->areCellsIncludedIn(nM1LevMesh,2,ret))
{
- int tmp2;
+ mcIdType tmp2;
ret->getMaxValue(tmp2);
ret->decrRef();
std::ostringstream oss; oss << "MEDCouplingUMesh::emulateMEDMEMBDC : input N-1 mesh present a cell not in descending mesh ... Id of cell is " << tmp2 << " !";
* Permutes the nodal connectivity arrays so that the cells are sorted by type, which is
* necessary for writing the mesh to MED file. Additionally returns a permutation array
* in "Old to New" mode.
- * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete
+ * \return DataArrayIdType * - a new instance of DataArrayIdType. The caller is to delete
* this array using decrRef() as it is no more needed.
* \throw If the nodal connectivity of cells is not defined.
*/
-DataArrayInt *MEDCouplingUMesh::sortCellsInMEDFileFrmt()
+DataArrayIdType *MEDCouplingUMesh::sortCellsInMEDFileFrmt()
{
checkConnectivityFullyDefined();
- MCAuto<DataArrayInt> ret=getRenumArrForMEDFileFrmt();
+ MCAuto<DataArrayIdType> ret=getRenumArrForMEDFileFrmt();
renumberCells(ret->begin(),false);
return ret.retn();
}
bool MEDCouplingUMesh::checkConsecutiveCellTypes() const
{
checkFullyDefined();
- const int *conn=_nodal_connec->begin();
- const int *connI=_nodal_connec_index->begin();
- int nbOfCells=getNumberOfCells();
+ const mcIdType *conn=_nodal_connec->begin();
+ const mcIdType *connI=_nodal_connec_index->begin();
+ mcIdType nbOfCells=getNumberOfCells();
std::set<INTERP_KERNEL::NormalizedCellType> types;
- for(const int *i=connI;i!=connI+nbOfCells;)
+ for(const mcIdType *i=connI;i!=connI+nbOfCells;)
{
INTERP_KERNEL::NormalizedCellType curType=(INTERP_KERNEL::NormalizedCellType)conn[*i];
if(types.find(curType)!=types.end())
return false;
types.insert(curType);
- i=std::find_if(i+1,connI+nbOfCells,MEDCouplingImpl::ConnReader(conn,(int)curType));
+ i=std::find_if(i+1,connI+nbOfCells,MEDCouplingImpl::ConnReader(conn,ToIdType(curType)));
}
return true;
}
/*!
* This method is a specialization of MEDCouplingUMesh::checkConsecutiveCellTypesAndOrder method that is called here.
* The geometric type order is specified by MED file.
- *
+ *
* \sa MEDCouplingUMesh::checkConsecutiveCellTypesAndOrder
*/
bool MEDCouplingUMesh::checkConsecutiveCellTypesForMEDFileFrmt() const
bool MEDCouplingUMesh::checkConsecutiveCellTypesAndOrder(const INTERP_KERNEL::NormalizedCellType *orderBg, const INTERP_KERNEL::NormalizedCellType *orderEnd) const
{
checkFullyDefined();
- const int *conn=_nodal_connec->begin();
- const int *connI=_nodal_connec_index->begin();
- int nbOfCells=getNumberOfCells();
+ const mcIdType *conn=_nodal_connec->begin();
+ const mcIdType *connI=_nodal_connec_index->begin();
+ mcIdType nbOfCells=getNumberOfCells();
if(nbOfCells==0)
return true;
- int lastPos=-1;
+ mcIdType lastPos=-1;
std::set<INTERP_KERNEL::NormalizedCellType> sg;
- for(const int *i=connI;i!=connI+nbOfCells;)
+ for(const mcIdType *i=connI;i!=connI+nbOfCells;)
{
INTERP_KERNEL::NormalizedCellType curType=(INTERP_KERNEL::NormalizedCellType)conn[*i];
const INTERP_KERNEL::NormalizedCellType *isTypeExists=std::find(orderBg,orderEnd,curType);
if(isTypeExists!=orderEnd)
{
- int pos=(int)std::distance(orderBg,isTypeExists);
+ mcIdType pos=ToIdType(std::distance(orderBg,isTypeExists));
if(pos<=lastPos)
return false;
lastPos=pos;
- i=std::find_if(i+1,connI+nbOfCells,MEDCouplingImpl::ConnReader(conn,(int)curType));
+ i=std::find_if(i+1,connI+nbOfCells,MEDCouplingImpl::ConnReader(conn,ToIdType(curType)));
}
else
{
if(sg.find(curType)==sg.end())
{
- i=std::find_if(i+1,connI+nbOfCells,MEDCouplingImpl::ConnReader(conn,(int)curType));
+ i=std::find_if(i+1,connI+nbOfCells,MEDCouplingImpl::ConnReader(conn,ToIdType(curType)));
sg.insert(curType);
}
else
}
/*!
- * This method returns 2 newly allocated DataArrayInt instances. The first is an array of size 'this->getNumberOfCells()' with one component,
+ * This method returns 2 newly allocated DataArrayIdType instances. The first is an array of size 'this->getNumberOfCells()' with one component,
* that tells for each cell the pos of its type in the array on type given in input parameter. The 2nd output parameter is an array with the same
* number of tuples than input type array and with one component. This 2nd output array gives type by type the number of occurrence of type in 'this'.
*/
-DataArrayInt *MEDCouplingUMesh::getLevArrPerCellTypes(const INTERP_KERNEL::NormalizedCellType *orderBg, const INTERP_KERNEL::NormalizedCellType *orderEnd, DataArrayInt *&nbPerType) const
+DataArrayIdType *MEDCouplingUMesh::getLevArrPerCellTypes(const INTERP_KERNEL::NormalizedCellType *orderBg, const INTERP_KERNEL::NormalizedCellType *orderEnd, DataArrayIdType *&nbPerType) const
{
checkConnectivityFullyDefined();
- int nbOfCells=getNumberOfCells();
- const int *conn=_nodal_connec->begin();
- const int *connI=_nodal_connec_index->begin();
- MCAuto<DataArrayInt> tmpa=DataArrayInt::New();
- MCAuto<DataArrayInt> tmpb=DataArrayInt::New();
+ mcIdType nbOfCells=getNumberOfCells();
+ const mcIdType *conn=_nodal_connec->begin();
+ const mcIdType *connI=_nodal_connec_index->begin();
+ MCAuto<DataArrayIdType> tmpa=DataArrayIdType::New();
+ MCAuto<DataArrayIdType> tmpb=DataArrayIdType::New();
tmpa->alloc(nbOfCells,1);
- tmpb->alloc((int)std::distance(orderBg,orderEnd),1);
+ tmpb->alloc(std::distance(orderBg,orderEnd),1);
tmpb->fillWithZero();
- int *tmp=tmpa->getPointer();
- int *tmp2=tmpb->getPointer();
- for(const int *i=connI;i!=connI+nbOfCells;i++)
+ mcIdType *tmp=tmpa->getPointer();
+ mcIdType *tmp2=tmpb->getPointer();
+ for(const mcIdType *i=connI;i!=connI+nbOfCells;i++)
{
const INTERP_KERNEL::NormalizedCellType *where=std::find(orderBg,orderEnd,(INTERP_KERNEL::NormalizedCellType)conn[*i]);
if(where!=orderEnd)
{
- int pos=(int)std::distance(orderBg,where);
+ mcIdType pos=ToIdType(std::distance(orderBg,where));
tmp2[pos]++;
tmp[std::distance(connI,i)]=pos;
}
*
* \sa MEDCouplingUMesh::getRenumArrForConsecutiveCellTypesSpec, MEDCouplingUMesh::sortCellsInMEDFileFrmt.
*/
-DataArrayInt *MEDCouplingUMesh::getRenumArrForMEDFileFrmt() const
+DataArrayIdType *MEDCouplingUMesh::getRenumArrForMEDFileFrmt() const
{
return getRenumArrForConsecutiveCellTypesSpec(MEDMEM_ORDER,MEDMEM_ORDER+N_MEDMEM_ORDER);
}
* The mesh after this call to MEDCouplingMesh::renumberCells will pass the test of MEDCouplingUMesh::checkConsecutiveCellTypesAndOrder with the same inputs.
* The returned array minimizes the permutations that is to say the order of cells inside same geometric type remains the same.
*/
-DataArrayInt *MEDCouplingUMesh::getRenumArrForConsecutiveCellTypesSpec(const INTERP_KERNEL::NormalizedCellType *orderBg, const INTERP_KERNEL::NormalizedCellType *orderEnd) const
+DataArrayIdType *MEDCouplingUMesh::getRenumArrForConsecutiveCellTypesSpec(const INTERP_KERNEL::NormalizedCellType *orderBg, const INTERP_KERNEL::NormalizedCellType *orderEnd) const
{
- DataArrayInt *nbPerType=0;
- MCAuto<DataArrayInt> tmpa=getLevArrPerCellTypes(orderBg,orderEnd,nbPerType);
+ DataArrayIdType *nbPerType=0;
+ MCAuto<DataArrayIdType> tmpa=getLevArrPerCellTypes(orderBg,orderEnd,nbPerType);
nbPerType->decrRef();
return tmpa->buildPermArrPerLevel();
}
*
* \return the array giving the correspondence old to new.
*/
-DataArrayInt *MEDCouplingUMesh::rearrange2ConsecutiveCellTypes()
+DataArrayIdType *MEDCouplingUMesh::rearrange2ConsecutiveCellTypes()
{
checkFullyDefined();
computeTypes();
- const int *conn=_nodal_connec->begin();
- const int *connI=_nodal_connec_index->begin();
- int nbOfCells=getNumberOfCells();
+ const mcIdType *conn=_nodal_connec->begin();
+ const mcIdType *connI=_nodal_connec_index->begin();
+ mcIdType nbOfCells=getNumberOfCells();
std::vector<INTERP_KERNEL::NormalizedCellType> types;
- for(const int *i=connI;i!=connI+nbOfCells && (types.size()!=_types.size());)
+ for(const mcIdType *i=connI;i!=connI+nbOfCells && (types.size()!=_types.size());)
if(std::find(types.begin(),types.end(),(INTERP_KERNEL::NormalizedCellType)conn[*i])==types.end())
{
INTERP_KERNEL::NormalizedCellType curType=(INTERP_KERNEL::NormalizedCellType)conn[*i];
types.push_back(curType);
for(i++;i!=connI+nbOfCells && (INTERP_KERNEL::NormalizedCellType)conn[*i]==curType;i++);
}
- DataArrayInt *ret=DataArrayInt::New();
+ DataArrayIdType *ret=DataArrayIdType::New();
ret->alloc(nbOfCells,1);
- int *retPtr=ret->getPointer();
+ mcIdType *retPtr=ret->getPointer();
std::fill(retPtr,retPtr+nbOfCells,-1);
- int newCellId=0;
+ mcIdType newCellId=0;
for(std::vector<INTERP_KERNEL::NormalizedCellType>::const_iterator iter=types.begin();iter!=types.end();iter++)
{
- for(const int *i=connI;i!=connI+nbOfCells;i++)
+ for(const mcIdType *i=connI;i!=connI+nbOfCells;i++)
if((INTERP_KERNEL::NormalizedCellType)conn[*i]==(*iter))
retPtr[std::distance(connI,i)]=newCellId++;
}
std::vector<MEDCouplingUMesh *> MEDCouplingUMesh::splitByType() const
{
checkConnectivityFullyDefined();
- const int *conn=_nodal_connec->begin();
- const int *connI=_nodal_connec_index->begin();
- int nbOfCells=getNumberOfCells();
+ const mcIdType *conn=_nodal_connec->begin();
+ const mcIdType *connI=_nodal_connec_index->begin();
+ mcIdType nbOfCells=getNumberOfCells();
std::vector<MEDCouplingUMesh *> ret;
- for(const int *i=connI;i!=connI+nbOfCells;)
+ for(const mcIdType *i=connI;i!=connI+nbOfCells;)
{
INTERP_KERNEL::NormalizedCellType curType=(INTERP_KERNEL::NormalizedCellType)conn[*i];
- int beginCellId=(int)std::distance(connI,i);
- i=std::find_if(i+1,connI+nbOfCells,MEDCouplingImpl::ConnReader(conn,(int)curType));
- int endCellId=(int)std::distance(connI,i);
- int sz=endCellId-beginCellId;
- int *cells=new int[sz];
- for(int j=0;j<sz;j++)
+ mcIdType beginCellId=ToIdType(std::distance(connI,i));
+ i=std::find_if(i+1,connI+nbOfCells,MEDCouplingImpl::ConnReader(conn,ToIdType(curType)));
+ mcIdType endCellId=ToIdType(std::distance(connI,i));
+ mcIdType sz=endCellId-beginCellId;
+ mcIdType *cells=new mcIdType[sz];
+ for(mcIdType j=0;j<sz;j++)
cells[j]=beginCellId+j;
MEDCouplingUMesh *m=(MEDCouplingUMesh *)buildPartOfMySelf(cells,cells+sz,true);
delete [] cells;
MEDCoupling1SGTUMesh *retC=dynamic_cast<MEDCoupling1SGTUMesh *>((MEDCoupling1GTUMesh*)ret);
if(retC)
{
- MCAuto<DataArrayInt> c=convertNodalConnectivityToStaticGeoTypeMesh();
+ MCAuto<DataArrayIdType> c=convertNodalConnectivityToStaticGeoTypeMesh();
retC->setNodalConnectivity(c);
}
else
MEDCoupling1DGTUMesh *retD=dynamic_cast<MEDCoupling1DGTUMesh *>((MEDCoupling1GTUMesh*)ret);
if(!retD)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::convertIntoSingleGeoTypeMesh : Internal error !");
- DataArrayInt *c=0,*ci=0;
+ DataArrayIdType *c=0,*ci=0;
convertNodalConnectivityToDynamicGeoTypeMesh(c,ci);
- MCAuto<DataArrayInt> cs(c),cis(ci);
+ MCAuto<DataArrayIdType> cs(c),cis(ci);
retD->setNodalConnectivity(cs,cis);
}
return ret.retn();
}
-DataArrayInt *MEDCouplingUMesh::convertNodalConnectivityToStaticGeoTypeMesh() const
+DataArrayIdType *MEDCouplingUMesh::convertNodalConnectivityToStaticGeoTypeMesh() const
{
checkConnectivityFullyDefined();
if(_types.size()!=1)
oss << "this type is dynamic ! Only static geometric type is possible for that type ! call convertNodalConnectivityToDynamicGeoTypeMesh instead !";
throw INTERP_KERNEL::Exception(oss.str());
}
- int nbCells=getNumberOfCells();
- int typi=(int)typ;
- int nbNodesPerCell=(int)cm.getNumberOfNodes();
- MCAuto<DataArrayInt> connOut=DataArrayInt::New(); connOut->alloc(nbCells*nbNodesPerCell,1);
- int *outPtr=connOut->getPointer();
- const int *conn=_nodal_connec->begin();
- const int *connI=_nodal_connec_index->begin();
+ mcIdType nbCells=getNumberOfCells();
+ mcIdType typi=ToIdType(typ);
+ mcIdType nbNodesPerCell=ToIdType(cm.getNumberOfNodes());
+ MCAuto<DataArrayIdType> connOut=DataArrayIdType::New(); connOut->alloc(nbCells*nbNodesPerCell,1);
+ mcIdType *outPtr=connOut->getPointer();
+ const mcIdType *conn=_nodal_connec->begin();
+ const mcIdType *connI=_nodal_connec_index->begin();
nbNodesPerCell++;
- for(int i=0;i<nbCells;i++,connI++)
+ for(mcIdType i=0;i<nbCells;i++,connI++)
{
if(conn[connI[0]]==typi && connI[1]-connI[0]==nbNodesPerCell)
outPtr=std::copy(conn+connI[0]+1,conn+connI[1],outPtr);
* \param nodalConn
* \param nodalConnI
*/
-void MEDCouplingUMesh::convertNodalConnectivityToDynamicGeoTypeMesh(DataArrayInt *&nodalConn, DataArrayInt *&nodalConnIndex) const
+void MEDCouplingUMesh::convertNodalConnectivityToDynamicGeoTypeMesh(DataArrayIdType *&nodalConn, DataArrayIdType *&nodalConnIndex) const
{
static const char msg0[]="MEDCouplingUMesh::convertNodalConnectivityToDynamicGeoTypeMesh : nodal connectivity in this are invalid ! Call checkConsistency !";
checkConnectivityFullyDefined();
if(_types.size()!=1)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::convertNodalConnectivityToDynamicGeoTypeMesh : current mesh does not contain exactly one geometric type !");
- int nbCells=getNumberOfCells(),lgth=_nodal_connec->getNumberOfTuples();
+ mcIdType nbCells=getNumberOfCells(),
+ lgth=_nodal_connec->getNumberOfTuples();
if(lgth<nbCells)
throw INTERP_KERNEL::Exception(msg0);
- MCAuto<DataArrayInt> c(DataArrayInt::New()),ci(DataArrayInt::New());
+ MCAuto<DataArrayIdType> c(DataArrayIdType::New()),ci(DataArrayIdType::New());
c->alloc(lgth-nbCells,1); ci->alloc(nbCells+1,1);
- int *cp(c->getPointer()),*cip(ci->getPointer());
- const int *incp(_nodal_connec->begin()),*incip(_nodal_connec_index->begin());
+ mcIdType *cp(c->getPointer()),*cip(ci->getPointer());
+ const mcIdType *incp(_nodal_connec->begin()),*incip(_nodal_connec_index->begin());
cip[0]=0;
- for(int i=0;i<nbCells;i++,cip++,incip++)
+ for(mcIdType i=0;i<nbCells;i++,cip++,incip++)
{
- int strt(incip[0]+1),stop(incip[1]);//+1 to skip geo type
- int delta(stop-strt);
+ mcIdType strt(incip[0]+1),stop(incip[1]);//+1 to skip geo type
+ mcIdType delta(stop-strt);
if(delta>=1)
{
if((strt>=0 && strt<lgth) && (stop>=0 && stop<=lgth))
*
* \param [in] ms meshes with same mesh dimension lying on the same coords and sorted by type following de the same geometric type order than
* those specified in MEDCouplingUMesh::sortCellsInMEDFileFrmt method.
- * \param [out] szOfCellGrpOfSameType is a newly allocated DataArrayInt instance whose number of tuples is equal to the number of chunks of same geotype
+ * \param [out] szOfCellGrpOfSameType is a newly allocated DataArrayIdType instance whose number of tuples is equal to the number of chunks of same geotype
* in all meshes in \b ms. The accumulation of all values of this array is equal to the number of cells of returned mesh.
- * \param [out] idInMsOfCellGrpOfSameType is a newly allocated DataArrayInt instance having the same size than \b szOfCellGrpOfSameType. This
+ * \param [out] idInMsOfCellGrpOfSameType is a newly allocated DataArrayIdType instance having the same size than \b szOfCellGrpOfSameType. This
* output array gives for each chunck of same type the corresponding mesh id in \b ms.
* \return A newly allocated unstructured mesh that is the result of the aggregation on same coords of all meshes in \b ms. This returned mesh
* is sorted by type following the geo cell types order of MEDCouplingUMesh::sortCellsInMEDFileFrmt method.
*/
MEDCouplingUMesh *MEDCouplingUMesh::AggregateSortedByTypeMeshesOnSameCoords(const std::vector<const MEDCouplingUMesh *>& ms,
- DataArrayInt *&szOfCellGrpOfSameType,
- DataArrayInt *&idInMsOfCellGrpOfSameType)
+ DataArrayIdType *&szOfCellGrpOfSameType,
+ DataArrayIdType *&idInMsOfCellGrpOfSameType)
{
std::vector<const MEDCouplingUMesh *> ms2;
for(std::vector<const MEDCouplingUMesh *>::const_iterator it=ms.begin();it!=ms.end();it++)
//
std::vector<const MEDCouplingUMesh *> m1ssmSingle;
std::vector< MCAuto<MEDCouplingUMesh> > m1ssmSingleAuto;
- int fake=0,rk=0;
- MCAuto<DataArrayInt> ret1(DataArrayInt::New()),ret2(DataArrayInt::New());
+ mcIdType fake=0,rk=0;
+ MCAuto<DataArrayIdType> ret1(DataArrayIdType::New()),ret2(DataArrayIdType::New());
ret1->alloc(0,1); ret2->alloc(0,1);
for(std::vector<const MEDCouplingUMesh *>::const_iterator it=ms2.begin();it!=ms2.end();it++,rk++)
{
}
}
MCAuto<MEDCouplingUMesh> m1ssmSingle2=MEDCouplingUMesh::MergeUMeshesOnSameCoords(m1ssmSingle);
- MCAuto<DataArrayInt> renum=m1ssmSingle2->sortCellsInMEDFileFrmt();
+ MCAuto<DataArrayIdType> renum=m1ssmSingle2->sortCellsInMEDFileFrmt();
std::vector<const MEDCouplingUMesh *> m1ssmfinal(m1ssm.size());
- for(std::size_t i=0;i<m1ssm.size();i++)
+ for(mcIdType i=0;i<ToIdType(m1ssm.size());i++)
m1ssmfinal[renum->getIJ(i,0)]=m1ssm[i];
MCAuto<MEDCouplingUMesh> ret0=MEDCouplingUMesh::MergeUMeshesOnSameCoords(m1ssmfinal);
szOfCellGrpOfSameType=ret1->renumber(renum->begin());
}
/*!
- * This method returns a newly created DataArrayInt instance.
+ * This method returns a newly created DataArrayIdType instance.
* This method retrieves cell ids in [ \a begin, \a end ) that have the type \a type.
*/
-DataArrayInt *MEDCouplingUMesh::keepCellIdsByType(INTERP_KERNEL::NormalizedCellType type, const int *begin, const int *end) const
+DataArrayIdType *MEDCouplingUMesh::keepCellIdsByType(INTERP_KERNEL::NormalizedCellType type, const mcIdType *begin, const mcIdType *end) const
{
checkFullyDefined();
- const int *conn=_nodal_connec->begin();
- const int *connIndex=_nodal_connec_index->begin();
- MCAuto<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
- for(const int *w=begin;w!=end;w++)
+ const mcIdType *conn=_nodal_connec->begin();
+ const mcIdType *connIndex=_nodal_connec_index->begin();
+ MCAuto<DataArrayIdType> ret(DataArrayIdType::New()); ret->alloc(0,1);
+ for(const mcIdType *w=begin;w!=end;w++)
if((INTERP_KERNEL::NormalizedCellType)conn[connIndex[*w]]==type)
ret->pushBackSilent(*w);
return ret.retn();
* This method makes the assumption that da->getNumberOfTuples()<this->getNumberOfCells(). This method makes the assumption that ids contained in 'da'
* are in [0:getNumberOfCells())
*/
-DataArrayInt *MEDCouplingUMesh::convertCellArrayPerGeoType(const DataArrayInt *da) const
+DataArrayIdType *MEDCouplingUMesh::convertCellArrayPerGeoType(const DataArrayIdType *da) const
{
checkFullyDefined();
- const int *conn=_nodal_connec->begin();
- const int *connI=_nodal_connec_index->begin();
- int nbOfCells=getNumberOfCells();
+ const mcIdType *conn=_nodal_connec->begin();
+ const mcIdType *connI=_nodal_connec_index->begin();
+ mcIdType nbOfCells=getNumberOfCells();
std::set<INTERP_KERNEL::NormalizedCellType> types(getAllGeoTypes());
- int *tmp=new int[nbOfCells];
+ mcIdType *tmp=new mcIdType[nbOfCells];
for(std::set<INTERP_KERNEL::NormalizedCellType>::const_iterator iter=types.begin();iter!=types.end();iter++)
{
- int j=0;
- for(const int *i=connI;i!=connI+nbOfCells;i++)
+ mcIdType j=0;
+ for(const mcIdType *i=connI;i!=connI+nbOfCells;i++)
if((INTERP_KERNEL::NormalizedCellType)conn[*i]==(*iter))
tmp[std::distance(connI,i)]=j++;
}
- DataArrayInt *ret=DataArrayInt::New();
+ DataArrayIdType *ret=DataArrayIdType::New();
ret->alloc(da->getNumberOfTuples(),da->getNumberOfComponents());
ret->copyStringInfoFrom(*da);
- int *retPtr=ret->getPointer();
- const int *daPtr=da->begin();
- int nbOfElems=da->getNbOfElems();
- for(int k=0;k<nbOfElems;k++)
+ mcIdType *retPtr=ret->getPointer();
+ const mcIdType *daPtr=da->begin();
+ mcIdType nbOfElems=da->getNbOfElems();
+ for(mcIdType k=0;k<nbOfElems;k++)
retPtr[k]=tmp[daPtr[k]];
delete [] tmp;
return ret;
* cells whose ids is in 'idsPerGeoType' array.
* This method conserves coords and name of mesh.
*/
-MEDCouplingUMesh *MEDCouplingUMesh::keepSpecifiedCells(INTERP_KERNEL::NormalizedCellType type, const int *idsPerGeoTypeBg, const int *idsPerGeoTypeEnd) const
+MEDCouplingUMesh *MEDCouplingUMesh::keepSpecifiedCells(INTERP_KERNEL::NormalizedCellType type, const mcIdType *idsPerGeoTypeBg, const mcIdType *idsPerGeoTypeEnd) const
{
- std::vector<int> code=getDistributionOfTypes();
+ std::vector<mcIdType> code=getDistributionOfTypes();
std::size_t nOfTypesInThis=code.size()/3;
- int sz=0,szOfType=0;
+ mcIdType sz=0,szOfType=0;
for(std::size_t i=0;i<nOfTypesInThis;i++)
{
if(code[3*i]!=type)
else
szOfType=code[3*i+1];
}
- for(const int *work=idsPerGeoTypeBg;work!=idsPerGeoTypeEnd;work++)
+ for(const mcIdType *work=idsPerGeoTypeBg;work!=idsPerGeoTypeEnd;work++)
if(*work<0 || *work>=szOfType)
{
std::ostringstream oss; oss << "MEDCouplingUMesh::keepSpecifiedCells : Request on type " << type << " at place #" << std::distance(idsPerGeoTypeBg,work) << " value " << *work;
oss << ". It should be in [0," << szOfType << ") !";
throw INTERP_KERNEL::Exception(oss.str());
}
- MCAuto<DataArrayInt> idsTokeep=DataArrayInt::New(); idsTokeep->alloc(sz+(int)std::distance(idsPerGeoTypeBg,idsPerGeoTypeEnd),1);
- int *idsPtr=idsTokeep->getPointer();
- int offset=0;
+ MCAuto<DataArrayIdType> idsTokeep=DataArrayIdType::New(); idsTokeep->alloc(sz+std::distance(idsPerGeoTypeBg,idsPerGeoTypeEnd),1);
+ mcIdType *idsPtr=idsTokeep->getPointer();
+ mcIdType offset=0;
for(std::size_t i=0;i<nOfTypesInThis;i++)
{
if(code[3*i]!=type)
- for(int j=0;j<code[3*i+1];j++)
+ for(mcIdType j=0;j<code[3*i+1];j++)
*idsPtr++=offset+j;
else
- idsPtr=std::transform(idsPerGeoTypeBg,idsPerGeoTypeEnd,idsPtr,std::bind2nd(std::plus<int>(),offset));
+ idsPtr=std::transform(idsPerGeoTypeBg,idsPerGeoTypeEnd,idsPtr,std::bind2nd(std::plus<mcIdType>(),offset));
offset+=code[3*i+1];
}
MCAuto<MEDCouplingUMesh> ret=static_cast<MEDCouplingUMesh *>(buildPartOfMySelf(idsTokeep->begin(),idsTokeep->end(),true));
*/
std::vector<bool> MEDCouplingUMesh::getQuadraticStatus() const
{
- int ncell=getNumberOfCells();
+ mcIdType ncell=getNumberOfCells();
std::vector<bool> ret(ncell);
- const int *cI=getNodalConnectivityIndex()->begin();
- const int *c=getNodalConnectivity()->begin();
- for(int i=0;i<ncell;i++)
+ const mcIdType *cI=getNodalConnectivityIndex()->begin();
+ const mcIdType *c=getNodalConnectivity()->begin();
+ for(mcIdType i=0;i<ncell;i++)
{
INTERP_KERNEL::NormalizedCellType typ=(INTERP_KERNEL::NormalizedCellType)c[cI[i]];
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(typ);
* Returns a new DataArrayDouble holding barycenters of all cells. The barycenter is
* computed by averaging coordinates of cell nodes, so this method is not a right
* choice for degenerated meshes (not well oriented, cells with measure close to zero).
+ * Beware also that for quadratic meshes, degenerated arc of circles are turned into linear edges for the computation.
+ * This happens with a default detection precision of eps=1.0e-14. If you need control over this use computeCellCenterOfMassWithPrecision().
* \return DataArrayDouble * - a new instance of DataArrayDouble, of size \a
* this->getNumberOfCells() tuples per \a this->getSpaceDimension()
* components. The caller is to delete this array using decrRef() as it is
* \throw If the coordinates array is not set.
* \throw If the nodal connectivity of cells is not defined.
* \sa MEDCouplingUMesh::computeIsoBarycenterOfNodesPerCell
+ * \sa MEDCouplingUMesh::computeCellCenterOfMassWithPrecision
*/
DataArrayDouble *MEDCouplingUMesh::computeCellCenterOfMass() const
{
MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
int spaceDim=getSpaceDimension();
- int nbOfCells=getNumberOfCells();
+ mcIdType nbOfCells=getNumberOfCells();
ret->alloc(nbOfCells,spaceDim);
ret->copyStringInfoFrom(*getCoords());
double *ptToFill=ret->getPointer();
- const int *nodal=_nodal_connec->begin();
- const int *nodalI=_nodal_connec_index->begin();
+ const mcIdType *nodal=_nodal_connec->begin();
+ const mcIdType *nodalI=_nodal_connec_index->begin();
const double *coor=_coords->begin();
- for(int i=0;i<nbOfCells;i++)
+ for(mcIdType i=0;i<nbOfCells;i++)
{
INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)nodal[nodalI[i]];
- INTERP_KERNEL::computeBarycenter2<int,INTERP_KERNEL::ALL_C_MODE>(type,nodal+nodalI[i]+1,nodalI[i+1]-nodalI[i]-1,coor,spaceDim,ptToFill);
+ INTERP_KERNEL::computeBarycenter2<mcIdType,INTERP_KERNEL::ALL_C_MODE>(type,nodal+nodalI[i]+1,nodalI[i+1]-nodalI[i]-1,coor,spaceDim,ptToFill);
ptToFill+=spaceDim;
}
return ret.retn();
}
+
+/*!
+ * See computeCellCenterOfMass().
+ * \param eps a precision for the detection of degenerated arc of circles.
+ * \return DataArrayDouble * - a new instance of DataArrayDouble, of size \a
+ * this->getNumberOfCells() tuples per \a this->getSpaceDimension()
+ * components. The caller is to delete this array using decrRef() as it is
+ * no more needed.
+ * \throw If the coordinates array is not set.
+ * \throw If the nodal connectivity of cells is not defined.
+ * \sa MEDCouplingUMesh::computeIsoBarycenterOfNodesPerCell
+ * \sa MEDCouplingUMesh::computeCellCenterOfMassWithPrecision
+ */
+DataArrayDouble *MEDCouplingUMesh::computeCellCenterOfMassWithPrecision(double eps) const
+{
+ INTERP_KERNEL::QuadraticPlanarPrecision prec(eps);
+ MCAuto<DataArrayDouble> ret = computeCellCenterOfMass();
+ return ret.retn();
+}
+
+
/*!
* This method computes for each cell in \a this, the location of the iso barycenter of nodes constituting
- * the cell. Contrary to badly named MEDCouplingUMesh::computeCellCenterOfMass method that returns the center of inertia of the
- *
- * \return a newly allocated DataArrayDouble instance that the caller has to deal with. The returned
+ * the cell. Contrary to badly named MEDCouplingUMesh::computeCellCenterOfMass method that returns the center of inertia of the
+ *
+ * \return a newly allocated DataArrayDouble instance that the caller has to deal with. The returned
* DataArrayDouble instance will have \c this->getNumberOfCells() tuples and \c this->getSpaceDimension() components.
- *
+ *
* \sa MEDCouplingUMesh::computeCellCenterOfMass
* \throw If \a this is not fully defined (coordinates and connectivity)
* \throw If there is presence in nodal connectivity in \a this of node ids not in [0, \c this->getNumberOfNodes() )
checkFullyDefined();
MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
int spaceDim=getSpaceDimension();
- int nbOfCells=getNumberOfCells();
- int nbOfNodes=getNumberOfNodes();
+ mcIdType nbOfCells=getNumberOfCells();
+ mcIdType nbOfNodes=getNumberOfNodes();
ret->alloc(nbOfCells,spaceDim);
double *ptToFill=ret->getPointer();
- const int *nodal=_nodal_connec->begin();
- const int *nodalI=_nodal_connec_index->begin();
+ const mcIdType *nodal=_nodal_connec->begin();
+ const mcIdType *nodalI=_nodal_connec_index->begin();
const double *coor=_coords->begin();
- for(int i=0;i<nbOfCells;i++,ptToFill+=spaceDim)
+ for(mcIdType i=0;i<nbOfCells;i++,ptToFill+=spaceDim)
{
INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)nodal[nodalI[i]];
std::fill(ptToFill,ptToFill+spaceDim,0.);
if(type!=INTERP_KERNEL::NORM_POLYHED)
{
- for(const int *conn=nodal+nodalI[i]+1;conn!=nodal+nodalI[i+1];conn++)
+ for(const mcIdType *conn=nodal+nodalI[i]+1;conn!=nodal+nodalI[i+1];conn++)
{
if(*conn>=0 && *conn<nbOfNodes)
std::transform(coor+spaceDim*conn[0],coor+spaceDim*(conn[0]+1),ptToFill,ptToFill,std::plus<double>());
throw INTERP_KERNEL::Exception(oss.str());
}
}
- int nbOfNodesInCell=nodalI[i+1]-nodalI[i]-1;
+ mcIdType nbOfNodesInCell=nodalI[i+1]-nodalI[i]-1;
if(nbOfNodesInCell>0)
std::transform(ptToFill,ptToFill+spaceDim,ptToFill,std::bind2nd(std::multiplies<double>(),1./(double)nbOfNodesInCell));
else
}
else
{
- std::set<int> s(nodal+nodalI[i]+1,nodal+nodalI[i+1]);
+ std::set<mcIdType> s(nodal+nodalI[i]+1,nodal+nodalI[i+1]);
s.erase(-1);
- for(std::set<int>::const_iterator it=s.begin();it!=s.end();it++)
+ for(std::set<mcIdType>::const_iterator it=s.begin();it!=s.end();it++)
{
if(*it>=0 && *it<nbOfNodes)
std::transform(coor+spaceDim*(*it),coor+spaceDim*((*it)+1),ptToFill,ptToFill,std::plus<double>());
/*!
* Returns a new DataArrayDouble holding barycenters of specified cells. The
* barycenter is computed by averaging coordinates of cell nodes. The cells to treat
- * are specified via an array of cell ids.
- * \warning Validity of the specified cell ids is not checked!
+ * are specified via an array of cell ids.
+ * \warning Validity of the specified cell ids is not checked!
* Valid range is [ 0, \a this->getNumberOfCells() ).
* \param [in] begin - an array of cell ids of interest.
* \param [in] end - the end of \a begin, i.e. a pointer to its (last+1)-th element.
* \return DataArrayDouble * - a new instance of DataArrayDouble, of size ( \a
* end - \a begin ) tuples per \a this->getSpaceDimension() components. The
- * caller is to delete this array using decrRef() as it is no more needed.
+ * caller is to delete this array using decrRef() as it is no more needed.
* \throw If the coordinates array is not set.
* \throw If the nodal connectivity of cells is not defined.
*
* \ref py_mcumesh_getPartBarycenterAndOwner "Here is a Python example".
* \endif
*/
-DataArrayDouble *MEDCouplingUMesh::getPartBarycenterAndOwner(const int *begin, const int *end) const
+DataArrayDouble *MEDCouplingUMesh::getPartBarycenterAndOwner(const mcIdType *begin, const mcIdType *end) const
{
DataArrayDouble *ret=DataArrayDouble::New();
int spaceDim=getSpaceDimension();
- int nbOfTuple=(int)std::distance(begin,end);
+ std::size_t nbOfTuple=std::distance(begin,end);
ret->alloc(nbOfTuple,spaceDim);
double *ptToFill=ret->getPointer();
double *tmp=new double[spaceDim];
- const int *nodal=_nodal_connec->begin();
- const int *nodalI=_nodal_connec_index->begin();
+ const mcIdType *nodal=_nodal_connec->begin();
+ const mcIdType *nodalI=_nodal_connec_index->begin();
const double *coor=_coords->begin();
- for(const int *w=begin;w!=end;w++)
+ for(const mcIdType *w=begin;w!=end;w++)
{
INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)nodal[nodalI[*w]];
- INTERP_KERNEL::computeBarycenter2<int,INTERP_KERNEL::ALL_C_MODE>(type,nodal+nodalI[*w]+1,nodalI[*w+1]-nodalI[*w]-1,coor,spaceDim,ptToFill);
+ INTERP_KERNEL::computeBarycenter2<mcIdType,INTERP_KERNEL::ALL_C_MODE>(type,nodal+nodalI[*w]+1,nodalI[*w+1]-nodalI[*w]-1,coor,spaceDim,ptToFill);
ptToFill+=spaceDim;
}
delete [] tmp;
* So this method expects that \a this has a spaceDimension equal to 3 and meshDimension equal to 2.
* The computation of the plane equation is done using each time the 3 first nodes of 2D cells.
* This method is useful to detect 2D cells in 3D space that are not coplanar.
- *
+ *
* \return DataArrayDouble * - a new instance of DataArrayDouble having 4 components and a number of tuples equal to number of cells in \a this.
* \throw If spaceDim!=3 or meshDim!=2.
* \throw If connectivity of \a this is invalid.
DataArrayDouble *MEDCouplingUMesh::computePlaneEquationOf3DFaces() const
{
MCAuto<DataArrayDouble> ret(DataArrayDouble::New());
- int nbOfCells(getNumberOfCells()),nbOfNodes(getNumberOfNodes());
+ mcIdType nbOfCells=getNumberOfCells();
+ mcIdType nbOfNodes(getNumberOfNodes());
if(getSpaceDimension()!=3 || getMeshDimension()!=2)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::computePlaneEquationOf3DFaces : This method must be applied on a mesh having meshDimension equal 2 and a spaceDimension equal to 3 !");
ret->alloc(nbOfCells,4);
double *retPtr(ret->getPointer());
- const int *nodal(_nodal_connec->begin()),*nodalI(_nodal_connec_index->begin());
+ const mcIdType *nodal(_nodal_connec->begin()),*nodalI(_nodal_connec_index->begin());
const double *coor(_coords->begin());
- for(int i=0;i<nbOfCells;i++,nodalI++,retPtr+=4)
+ for(mcIdType i=0;i<nbOfCells;i++,nodalI++,retPtr+=4)
{
double matrix[16]={0,0,0,1,0,0,0,1,0,0,0,1,1,1,1,0},matrix2[16];
if(nodalI[1]-nodalI[0]>=4)
coor[nodal[nodalI[0]+1+2]*3+1]-coor[nodal[nodalI[0]+1+0]*3+1],
coor[nodal[nodalI[0]+1+2]*3+2]-coor[nodal[nodalI[0]+1+0]*3+2]};
double cc[3]={aa[1]*bb[2]-aa[2]*bb[1],aa[2]*bb[0]-aa[0]*bb[2],aa[0]*bb[1]-aa[1]*bb[0]};
+ double aa_norm(sqrt(aa[0]*aa[0]+aa[1]*aa[1]+aa[2]*aa[2])),bb_norm(sqrt(bb[0]*bb[0]+bb[1]*bb[1]+bb[2]*bb[2]));
for(int j=0;j<3;j++)
{
- int nodeId(nodal[nodalI[0]+1+j]);
+ mcIdType nodeId(nodal[nodalI[0]+1+j]);
if(nodeId>=0 && nodeId<nbOfNodes)
std::copy(coor+nodeId*3,coor+(nodeId+1)*3,matrix+4*j);
else
throw INTERP_KERNEL::Exception(oss.str());
}
}
- if(sqrt(cc[0]*cc[0]+cc[1]*cc[1]+cc[2]*cc[2])>1e-7)
+ if(sqrt(cc[0]*cc[0]+cc[1]*cc[1]+cc[2]*cc[2])>(1e-3*aa_norm*bb_norm))
{
INTERP_KERNEL::inverseMatrix(matrix,4,matrix2);
retPtr[0]=matrix2[3]; retPtr[1]=matrix2[7]; retPtr[2]=matrix2[11]; retPtr[3]=matrix2[15];
}
//
double dd[3]={0.,0.,0.};
- for(int offset=nodalI[0]+1;offset<nodalI[1];offset++)
+ for(mcIdType offset=nodalI[0]+1;offset<nodalI[1];offset++)
std::transform(coor+3*nodal[offset],coor+3*(nodal[offset]+1),dd,dd,std::plus<double>());
- int nbOfNodesInCell(nodalI[1]-nodalI[0]-1);
+ mcIdType nbOfNodesInCell(nodalI[1]-nodalI[0]-1);
std::transform(dd,dd+3,dd,std::bind2nd(std::multiplies<double>(),1./(double)nbOfNodesInCell));
std::copy(dd,dd+3,matrix+4*2);
INTERP_KERNEL::inverseMatrix(matrix,4,matrix2);
/*!
* This method expects as input a DataArrayDouble non nul instance 'da' that should be allocated. If not an exception is thrown.
- *
+ *
*/
MEDCouplingUMesh *MEDCouplingUMesh::Build0DMeshFromCoords(DataArrayDouble *da)
{
if(name.empty())
ret->setName("Mesh");
ret->setCoords(da);
- int nbOfTuples(da->getNumberOfTuples());
- MCAuto<DataArrayInt> c(DataArrayInt::New()),cI(DataArrayInt::New());
+ mcIdType nbOfTuples(da->getNumberOfTuples());
+ MCAuto<DataArrayIdType> c(DataArrayIdType::New()),cI(DataArrayIdType::New());
c->alloc(2*nbOfTuples,1);
cI->alloc(nbOfTuples+1,1);
- int *cp(c->getPointer()),*cip(cI->getPointer());
+ mcIdType *cp(c->getPointer()),*cip(cI->getPointer());
*cip++=0;
- for(int i=0;i<nbOfTuples;i++)
+ for(mcIdType i=0;i<nbOfTuples;i++)
{
*cp++=INTERP_KERNEL::NORM_POINT1;
*cp++=i;
const MEDCouplingUMesh *cur=a[i];
const DataArrayDouble *coo=cur->getCoords();
if(coo)
- spaceDim=coo->getNumberOfComponents();
+ spaceDim=int(coo->getNumberOfComponents());
}
if(spaceDim==-3)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::MergeUMeshes : no spaceDim specified ! unable to perform merge !");
const DataArrayDouble *coords=meshes.front()->getCoords();
int meshDim=meshes.front()->getMeshDimension();
std::vector<const MEDCouplingUMesh *>::const_iterator iter=meshes.begin();
- int meshLgth=0;
- int meshIndexLgth=0;
+ mcIdType meshLgth=0;
+ mcIdType meshIndexLgth=0;
for(;iter!=meshes.end();iter++)
{
if(coords!=(*iter)->getCoords())
meshLgth+=(*iter)->getNodalConnectivityArrayLen();
meshIndexLgth+=(*iter)->getNumberOfCells();
}
- MCAuto<DataArrayInt> nodal=DataArrayInt::New();
+ MCAuto<DataArrayIdType> nodal=DataArrayIdType::New();
nodal->alloc(meshLgth,1);
- int *nodalPtr=nodal->getPointer();
- MCAuto<DataArrayInt> nodalIndex=DataArrayInt::New();
+ mcIdType *nodalPtr=nodal->getPointer();
+ MCAuto<DataArrayIdType> nodalIndex=DataArrayIdType::New();
nodalIndex->alloc(meshIndexLgth+1,1);
- int *nodalIndexPtr=nodalIndex->getPointer();
- int offset=0;
+ mcIdType *nodalIndexPtr=nodalIndex->getPointer();
+ mcIdType offset=0;
for(iter=meshes.begin();iter!=meshes.end();iter++)
{
- const int *nod=(*iter)->getNodalConnectivity()->begin();
- const int *index=(*iter)->getNodalConnectivityIndex()->begin();
- int nbOfCells=(*iter)->getNumberOfCells();
- int meshLgth2=(*iter)->getNodalConnectivityArrayLen();
+ const mcIdType *nod=(*iter)->getNodalConnectivity()->begin();
+ const mcIdType *index=(*iter)->getNodalConnectivityIndex()->begin();
+ mcIdType nbOfCells=(*iter)->getNumberOfCells();
+ mcIdType meshLgth2=(*iter)->getNodalConnectivityArrayLen();
nodalPtr=std::copy(nod,nod+meshLgth2,nodalPtr);
if(iter!=meshes.begin())
- nodalIndexPtr=std::transform(index+1,index+nbOfCells+1,nodalIndexPtr,std::bind2nd(std::plus<int>(),offset));
+ nodalIndexPtr=std::transform(index+1,index+nbOfCells+1,nodalIndexPtr,std::bind2nd(std::plus<mcIdType>(),offset));
else
nodalIndexPtr=std::copy(index,index+nbOfCells+1,nodalIndexPtr);
offset+=meshLgth2;
* \param [in] meshes - a vector of meshes (MEDCouplingUMesh) to concatenate.
* \param [in] compType - specifies a cell comparison technique. For meaning of its
* valid values [0,1,2], see zipConnectivityTraducer().
- * \param [in,out] corr - an array of DataArrayInt, of the same size as \a
+ * \param [in,out] corr - an array of DataArrayIdType, of the same size as \a
* meshes. The *i*-th array describes cell ids mapping for \a meshes[ *i* ]
* mesh. The caller is to delete each of the arrays using decrRef() as it is
* no more needed.
* \throw If the nodal connectivity of cells of any of \a meshes is not defined.
* \throw If the nodal connectivity any of \a meshes includes an invalid id.
*/
-MEDCouplingUMesh *MEDCouplingUMesh::FuseUMeshesOnSameCoords(const std::vector<const MEDCouplingUMesh *>& meshes, int compType, std::vector<DataArrayInt *>& corr)
+MEDCouplingUMesh *MEDCouplingUMesh::FuseUMeshesOnSameCoords(const std::vector<const MEDCouplingUMesh *>& meshes, int compType, std::vector<DataArrayIdType *>& corr)
{
//All checks are delegated to MergeUMeshesOnSameCoords
MCAuto<MEDCouplingUMesh> ret=MergeUMeshesOnSameCoords(meshes);
- MCAuto<DataArrayInt> o2n=ret->zipConnectivityTraducer(compType);
+ MCAuto<DataArrayIdType> o2n=ret->zipConnectivityTraducer(compType);
corr.resize(meshes.size());
std::size_t nbOfMeshes=meshes.size();
- int offset=0;
- const int *o2nPtr=o2n->begin();
+ mcIdType offset=0;
+ const mcIdType *o2nPtr=o2n->begin();
for(std::size_t i=0;i<nbOfMeshes;i++)
{
- DataArrayInt *tmp=DataArrayInt::New();
- int curNbOfCells=meshes[i]->getNumberOfCells();
+ DataArrayIdType *tmp=DataArrayIdType::New();
+ mcIdType curNbOfCells=meshes[i]->getNumberOfCells();
tmp->alloc(curNbOfCells,1);
std::copy(o2nPtr+offset,o2nPtr+offset+curNbOfCells,tmp->getPointer());
offset+=curNbOfCells;
}
MCAuto<DataArrayDouble> res=DataArrayDouble::Aggregate(coords);
std::vector<MEDCouplingUMesh *>::const_iterator it=meshes.begin();
- int offset=(*it)->getNumberOfNodes();
+ mcIdType offset=(*it)->getNumberOfNodes();
(*it++)->setCoords(res);
for(;it!=meshes.end();it++)
{
- int oldNumberOfNodes=(*it)->getNumberOfNodes();
+ mcIdType oldNumberOfNodes=(*it)->getNumberOfNodes();
(*it)->setCoords(res);
(*it)->shiftNodeNumbersInConn(offset);
offset+=oldNumberOfNodes;
* the nodal connectivity array. The given meshes **can be of different** mesh
* dimension. This method is particularly useful in MEDLoader context to build a \ref
* MEDCoupling::MEDFileUMesh "MEDFileUMesh" instance that expects that underlying
- * MEDCouplingUMesh'es of different dimension share the same nodal connectivity array.
+ * MEDCouplingUMesh'es of different dimension share the same nodal connectivity array.
* \param [in,out] meshes - a vector of meshes to update.
* \param [in] eps - the precision used to detect coincident nodes (infinite norm).
* \throw If any of \a meshes is NULL.
if(!coo)
return;
//
- DataArrayInt *comm,*commI;
+ DataArrayIdType *comm,*commI;
coo->findCommonTuples(eps,-1,comm,commI);
- MCAuto<DataArrayInt> tmp1(comm),tmp2(commI);
- int oldNbOfNodes=coo->getNumberOfTuples();
- int newNbOfNodes;
- MCAuto<DataArrayInt> o2n=DataArrayInt::ConvertIndexArrayToO2N(oldNbOfNodes,comm->begin(),commI->begin(),commI->end(),newNbOfNodes);
+ MCAuto<DataArrayIdType> tmp1(comm),tmp2(commI);
+ mcIdType oldNbOfNodes=coo->getNumberOfTuples();
+ mcIdType newNbOfNodes;
+ MCAuto<DataArrayIdType> o2n=DataArrayIdType::ConvertIndexArrayToO2N(oldNbOfNodes,comm->begin(),commI->begin(),commI->end(),newNbOfNodes);
if(oldNbOfNodes==newNbOfNodes)
return ;
MCAuto<DataArrayDouble> newCoords=coo->renumberAndReduce(o2n->begin(),newNbOfNodes);
{
(*it)->renumberNodesInConn(o2n->begin());
(*it)->setCoords(newCoords);
- }
+ }
}
/*!
* This static operates only for coords in 3D. The polygon is specified by its connectivity nodes in [ \a begin , \a end ).
*/
-bool MEDCouplingUMesh::IsPolygonWellOriented(bool isQuadratic, const double *vec, const int *begin, const int *end, const double *coords)
+bool MEDCouplingUMesh::IsPolygonWellOriented(bool isQuadratic, const double *vec, const mcIdType *begin, const mcIdType *end, const double *coords)
{
std::size_t i, ip1;
double v[3]={0.,0.,0.};
std::size_t sz=std::distance(begin,end);
- if(isQuadratic)
- sz/=2;
- for(i=0;i<sz;i++)
- {
- v[0]+=coords[3*begin[i]+1]*coords[3*begin[(i+1)%sz]+2]-coords[3*begin[i]+2]*coords[3*begin[(i+1)%sz]+1];
- v[1]+=coords[3*begin[i]+2]*coords[3*begin[(i+1)%sz]]-coords[3*begin[i]]*coords[3*begin[(i+1)%sz]+2];
- v[2]+=coords[3*begin[i]]*coords[3*begin[(i+1)%sz]+1]-coords[3*begin[i]+1]*coords[3*begin[(i+1)%sz]];
- }
- double ret = vec[0]*v[0]+vec[1]*v[1]+vec[2]*v[2];
-
- // Try using quadratic points if standard points are degenerated (for example a QPOLYG with two
- // SEG3 forming a circle):
- if (fabs(ret) < INTERP_KERNEL::DEFAULT_ABS_TOL && isQuadratic)
+ if(!isQuadratic)
+ for(i=0;i<sz;i++)
+ {
+ // Algorithm: sum in v the cross products of (e1, e2) where e_i it the vector between (0,0,0) and point i
+ // and e2 is linear point directly following e1 in the connectivity. All points are used.
+ v[0]+=coords[3*begin[i]+1]*coords[3*begin[(i+1)%sz]+2]-coords[3*begin[i]+2]*coords[3*begin[(i+1)%sz]+1];
+ v[1]+=coords[3*begin[i]+2]*coords[3*begin[(i+1)%sz]]-coords[3*begin[i]]*coords[3*begin[(i+1)%sz]+2];
+ v[2]+=coords[3*begin[i]]*coords[3*begin[(i+1)%sz]+1]-coords[3*begin[i]+1]*coords[3*begin[(i+1)%sz]];
+ }
+ else
{
- v[0] = 0.0; v[1] = 0.0; v[2] = 0.0;
+ // Same algorithm as above but also using intermediate quadratic points.
+ // (taking only linear points might lead to issues if the linearized version of the
+ // polygon is not convex or self-intersecting ... see testCellOrientation4)
+ std::size_t hsz = sz/2;
for(std::size_t j=0;j<sz;j++)
{
if (j%2) // current point i is quadratic, next point i+1 is standard
{
- i = sz+j;
- ip1 = (j+1)%sz; // ip1 = "i+1"
+ i = hsz+(j-1)/2;
+ ip1 = ((j-1)/2 + 1)%hsz; // ip1 means "i+1", i.e. next point
}
else // current point i is standard, next point i+1 is quadratic
{
- i = j;
- ip1 = j+sz;
+ i = j/2;
+ ip1 = j/2+hsz;
}
v[0]+=coords[3*begin[i]+1]*coords[3*begin[ip1]+2]-coords[3*begin[i]+2]*coords[3*begin[ip1]+1];
v[1]+=coords[3*begin[i]+2]*coords[3*begin[ip1]]-coords[3*begin[i]]*coords[3*begin[ip1]+2];
v[2]+=coords[3*begin[i]]*coords[3*begin[ip1]+1]-coords[3*begin[i]+1]*coords[3*begin[ip1]];
}
- ret = vec[0]*v[0]+vec[1]*v[1]+vec[2]*v[2];
}
+ double ret = vec[0]*v[0]+vec[1]*v[1]+vec[2]*v[2];
return (ret>0.);
}
/*!
* The polyhedron is specified by its connectivity nodes in [ \a begin , \a end ).
*/
-bool MEDCouplingUMesh::IsPolyhedronWellOriented(const int *begin, const int *end, const double *coords)
+bool MEDCouplingUMesh::IsPolyhedronWellOriented(const mcIdType *begin, const mcIdType *end, const double *coords)
{
- std::vector<std::pair<int,int> > edges;
+ std::vector<std::pair<mcIdType,mcIdType> > edges;
std::size_t nbOfFaces=std::count(begin,end,-1)+1;
- const int *bgFace=begin;
+ const mcIdType *bgFace=begin;
for(std::size_t i=0;i<nbOfFaces;i++)
{
- const int *endFace=std::find(bgFace+1,end,-1);
+ const mcIdType *endFace=std::find(bgFace+1,end,-1);
std::size_t nbOfEdgesInFace=std::distance(bgFace,endFace);
for(std::size_t j=0;j<nbOfEdgesInFace;j++)
{
- std::pair<int,int> p1(bgFace[j],bgFace[(j+1)%nbOfEdgesInFace]);
+ std::pair<mcIdType,mcIdType> p1(bgFace[j],bgFace[(j+1)%nbOfEdgesInFace]);
if(std::find(edges.begin(),edges.end(),p1)!=edges.end())
return false;
edges.push_back(p1);
}
bgFace=endFace+1;
}
- return INTERP_KERNEL::calculateVolumeForPolyh2<int,INTERP_KERNEL::ALL_C_MODE>(begin,(int)std::distance(begin,end),coords)>-EPS_FOR_POLYH_ORIENTATION;
+ return INTERP_KERNEL::calculateVolumeForPolyh2<mcIdType,INTERP_KERNEL::ALL_C_MODE>(begin,ToIdType(std::distance(begin,end)),coords)>-EPS_FOR_POLYH_ORIENTATION;
}
/*!
* The 3D extruded static cell (PENTA6,HEXA8,HEXAGP12...) its connectivity nodes in [ \a begin , \a end ).
*/
-bool MEDCouplingUMesh::Is3DExtrudedStaticCellWellOriented(const int *begin, const int *end, const double *coords)
+bool MEDCouplingUMesh::Is3DExtrudedStaticCellWellOriented(const mcIdType *begin, const mcIdType *end, const double *coords)
{
double vec0[3],vec1[3];
std::size_t sz=std::distance(begin,end);
if(sz%2!=0)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::Is3DExtrudedStaticCellWellOriented : the length of nodal connectivity of extruded cell is not even !");
- int nbOfNodes=(int)sz/2;
- INTERP_KERNEL::areaVectorOfPolygon<int,INTERP_KERNEL::ALL_C_MODE>(begin,nbOfNodes,coords,vec0);
+ mcIdType nbOfNodes=ToIdType(sz/2);
+ INTERP_KERNEL::areaVectorOfPolygon<mcIdType,INTERP_KERNEL::ALL_C_MODE>(begin,nbOfNodes,coords,vec0);
const double *pt0=coords+3*begin[0];
const double *pt1=coords+3*begin[nbOfNodes];
vec1[0]=pt1[0]-pt0[0]; vec1[1]=pt1[1]-pt0[1]; vec1[2]=pt1[2]-pt0[2];
return (vec0[0]*vec1[0]+vec0[1]*vec1[1]+vec0[2]*vec1[2])<0.;
}
-void MEDCouplingUMesh::CorrectExtrudedStaticCell(int *begin, int *end)
+void MEDCouplingUMesh::CorrectExtrudedStaticCell(mcIdType *begin, mcIdType *end)
{
std::size_t sz=std::distance(begin,end);
- INTERP_KERNEL::AutoPtr<int> tmp=new int[sz];
+ INTERP_KERNEL::AutoPtr<mcIdType> tmp=new mcIdType[sz];
std::size_t nbOfNodes(sz/2);
- std::copy(begin,end,(int *)tmp);
+ std::copy(begin,end,(mcIdType *)tmp);
for(std::size_t j=1;j<nbOfNodes;j++)
{
begin[j]=tmp[nbOfNodes-j];
}
}
-bool MEDCouplingUMesh::IsTetra4WellOriented(const int *begin, const int *end, const double *coords)
+bool MEDCouplingUMesh::IsTetra4WellOriented(const mcIdType *begin, const mcIdType *end, const double *coords)
{
std::size_t sz=std::distance(begin,end);
if(sz!=4)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::IsTetra4WellOriented : Tetra4 cell with not 4 nodes ! Call checkConsistency !");
double vec0[3],vec1[3];
const double *pt0=coords+3*begin[0],*pt1=coords+3*begin[1],*pt2=coords+3*begin[2],*pt3=coords+3*begin[3];
- vec0[0]=pt1[0]-pt0[0]; vec0[1]=pt1[1]-pt0[1]; vec0[2]=pt1[2]-pt0[2]; vec1[0]=pt2[0]-pt0[0]; vec1[1]=pt2[1]-pt0[1]; vec1[2]=pt2[2]-pt0[2];
+ vec0[0]=pt1[0]-pt0[0]; vec0[1]=pt1[1]-pt0[1]; vec0[2]=pt1[2]-pt0[2]; vec1[0]=pt2[0]-pt0[0]; vec1[1]=pt2[1]-pt0[1]; vec1[2]=pt2[2]-pt0[2];
return ((vec0[1]*vec1[2]-vec0[2]*vec1[1])*(pt3[0]-pt0[0])+(vec0[2]*vec1[0]-vec0[0]*vec1[2])*(pt3[1]-pt0[1])+(vec0[0]*vec1[1]-vec0[1]*vec1[0])*(pt3[2]-pt0[2]))<0;
}
-bool MEDCouplingUMesh::IsPyra5WellOriented(const int *begin, const int *end, const double *coords)
+bool MEDCouplingUMesh::IsPyra5WellOriented(const mcIdType *begin, const mcIdType *end, const double *coords)
{
std::size_t sz=std::distance(begin,end);
if(sz!=5)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::IsPyra5WellOriented : Pyra5 cell with not 5 nodes ! Call checkConsistency !");
double vec0[3];
- INTERP_KERNEL::areaVectorOfPolygon<int,INTERP_KERNEL::ALL_C_MODE>(begin,4,coords,vec0);
+ INTERP_KERNEL::areaVectorOfPolygon<mcIdType,INTERP_KERNEL::ALL_C_MODE>(begin,4,coords,vec0);
const double *pt0=coords+3*begin[0],*pt1=coords+3*begin[4];
return (vec0[0]*(pt1[0]-pt0[0])+vec0[1]*(pt1[1]-pt0[1])+vec0[2]*(pt1[2]-pt0[2]))<0.;
}
/*!
- * This method performs a simplyfication of a single polyedron cell. To do that each face of cell whose connectivity is defined by [ \b begin , \b end )
+ * This method performs a simplyfication of a single polyedron cell. To do that each face of cell whose connectivity is defined by [ \b begin , \b end )
* is compared with the others in order to find faces in the same plane (with approx of eps). If any, the cells are grouped together and projected to
* a 2D space.
*
* \param [in] end end of nodal connectivity of a single polyhedron cell (excluded)
* \param [out] res the result is put at the end of the vector without any alteration of the data.
*/
-void MEDCouplingUMesh::SimplifyPolyhedronCell(double eps, const DataArrayDouble *coords, int index, DataArrayInt *res, MEDCouplingUMesh *faces,
- DataArrayInt *E_Fi, DataArrayInt *E_F, DataArrayInt *F_Ei, DataArrayInt *F_E)
+void MEDCouplingUMesh::SimplifyPolyhedronCell(double eps, const DataArrayDouble *coords, mcIdType index, DataArrayIdType *res, MEDCouplingUMesh *faces,
+ DataArrayIdType *E_Fi, DataArrayIdType *E_F, DataArrayIdType *F_Ei, DataArrayIdType *F_E)
{
- int nbFaces = E_Fi->getIJ(index + 1, 0) - E_Fi->getIJ(index, 0);
+ mcIdType nbFaces = E_Fi->getIJ(index + 1, 0) - E_Fi->getIJ(index, 0);
MCAuto<DataArrayDouble> v=DataArrayDouble::New(); v->alloc(nbFaces,3);
double *vPtr=v->getPointer();
MCAuto<DataArrayDouble> p=DataArrayDouble::New(); p->alloc(nbFaces,2);
double *pPtr=p->getPointer();
- int *e_fi = E_Fi->getPointer(), *e_f = E_F->getPointer(), *f_ei = F_Ei->getPointer(), *f_e = F_E->getPointer();
- const int *f_idx = faces->getNodalConnectivityIndex()->getPointer(), *f_cnn = faces->getNodalConnectivity()->getPointer();
- for(int i=0;i<nbFaces;i++,vPtr+=3,pPtr++)
+ mcIdType *e_fi = E_Fi->getPointer(), *e_f = E_F->getPointer(), *f_ei = F_Ei->getPointer(), *f_e = F_E->getPointer();
+ const mcIdType *f_idx = faces->getNodalConnectivityIndex()->getPointer(), *f_cnn = faces->getNodalConnectivity()->getPointer();
+ for(mcIdType i=0;i<nbFaces;i++,vPtr+=3,pPtr++)
{
- int face = e_f[e_fi[index] + i];
+ mcIdType face = e_f[e_fi[index] + i];
ComputeVecAndPtOfFace(eps, coords->begin(), f_cnn + f_idx[face] + 1, f_cnn + f_idx[face + 1], vPtr, pPtr);
// to differentiate faces going to different cells:
pPtr++, *pPtr = 0;
- for (int j = f_ei[face]; j < f_ei[face + 1]; j++)
- *pPtr += f_e[j];
+ for (mcIdType j = f_ei[face]; j < f_ei[face + 1]; j++)
+ *pPtr += FromIdType<double>(f_e[j]);
}
pPtr=p->getPointer(); vPtr=v->getPointer();
- DataArrayInt *comm1=0,*commI1=0;
+ DataArrayIdType *comm1=0,*commI1=0;
v->findCommonTuples(eps,-1,comm1,commI1);
- for (int i = 0; i < nbFaces; i++)
+ for (mcIdType i = 0; i < nbFaces; i++)
if (comm1->findIdFirstEqual(i) < 0)
{
comm1->pushBackSilent(i);
commI1->pushBackSilent(comm1->getNumberOfTuples());
}
- MCAuto<DataArrayInt> comm1Auto(comm1),commI1Auto(commI1);
- const int *comm1Ptr=comm1->begin();
- const int *commI1Ptr=commI1->begin();
- int nbOfGrps1=commI1Auto->getNumberOfTuples()-1;
- res->pushBackSilent((int)INTERP_KERNEL::NORM_POLYHED);
+ MCAuto<DataArrayIdType> comm1Auto(comm1),commI1Auto(commI1);
+ const mcIdType *comm1Ptr=comm1->begin();
+ const mcIdType *commI1Ptr=commI1->begin();
+ mcIdType nbOfGrps1=commI1Auto->getNumberOfTuples()-1;
+ res->pushBackSilent(ToIdType(INTERP_KERNEL::NORM_POLYHED));
//
- for(int i=0;i<nbOfGrps1;i++)
+ for(mcIdType i=0;i<nbOfGrps1;i++)
{
- int vecId=comm1Ptr[commI1Ptr[i]];
+ mcIdType vecId=comm1Ptr[commI1Ptr[i]];
MCAuto<DataArrayDouble> tmpgrp2=p->selectByTupleId(comm1Ptr+commI1Ptr[i],comm1Ptr+commI1Ptr[i+1]);
- DataArrayInt *comm2=0,*commI2=0;
+ DataArrayIdType *comm2=0,*commI2=0;
tmpgrp2->findCommonTuples(eps,-1,comm2,commI2);
- for (int j = 0; j < commI1Ptr[i+1] - commI1Ptr[i]; j++)
+ for (mcIdType j = 0; j < commI1Ptr[i+1] - commI1Ptr[i]; j++)
if (comm2->findIdFirstEqual(j) < 0)
{
comm2->pushBackSilent(j);
commI2->pushBackSilent(comm2->getNumberOfTuples());
}
- MCAuto<DataArrayInt> comm2Auto(comm2),commI2Auto(commI2);
- const int *comm2Ptr=comm2->begin();
- const int *commI2Ptr=commI2->begin();
- int nbOfGrps2=commI2Auto->getNumberOfTuples()-1;
- for(int j=0;j<nbOfGrps2;j++)
+ MCAuto<DataArrayIdType> comm2Auto(comm2),commI2Auto(commI2);
+ const mcIdType *comm2Ptr=comm2->begin();
+ const mcIdType *commI2Ptr=commI2->begin();
+ mcIdType nbOfGrps2=commI2Auto->getNumberOfTuples()-1;
+ for(mcIdType j=0;j<nbOfGrps2;j++)
{
if(commI2Ptr[j+1] == commI2Ptr[j] + 1)
{
- int face = e_f[e_fi[index] + comm1Ptr[commI1Ptr[i] + comm2Ptr[commI2Ptr[j]]]]; //hmmm
+ mcIdType face = e_f[e_fi[index] + comm1Ptr[commI1Ptr[i] + comm2Ptr[commI2Ptr[j]]]]; //hmmm
res->insertAtTheEnd(f_cnn + f_idx[face] + 1, f_cnn + f_idx[face + 1]);
res->pushBackSilent(-1);
}
else
{
- int pointId=comm1Ptr[commI1Ptr[i]+comm2Ptr[commI2Ptr[j]]];
- MCAuto<DataArrayInt> ids2=comm2->selectByTupleIdSafeSlice(commI2Ptr[j],commI2Ptr[j+1],1);
+ mcIdType pointId=comm1Ptr[commI1Ptr[i]+comm2Ptr[commI2Ptr[j]]];
+ MCAuto<DataArrayIdType> ids2=comm2->selectByTupleIdSafeSlice(commI2Ptr[j],commI2Ptr[j+1],1);
ids2->transformWithIndArr(comm1Ptr+commI1Ptr[i],comm1Ptr+commI1Ptr[i+1]);
ids2->transformWithIndArr(e_f + e_fi[index], e_f + e_fi[index + 1]);
MCAuto<MEDCouplingUMesh> mm3=static_cast<MEDCouplingUMesh *>(faces->buildPartOfMySelf(ids2->begin(),ids2->end(),true));
- MCAuto<DataArrayInt> idsNodeTmp=mm3->zipCoordsTraducer();
- MCAuto<DataArrayInt> idsNode=idsNodeTmp->invertArrayO2N2N2O(mm3->getNumberOfNodes());
- const int *idsNodePtr=idsNode->begin();
+ MCAuto<DataArrayIdType> idsNodeTmp=mm3->zipCoordsTraducer();
+ MCAuto<DataArrayIdType> idsNode=idsNodeTmp->invertArrayO2N2N2O(mm3->getNumberOfNodes());
+ const mcIdType *idsNodePtr=idsNode->begin();
double center[3]; center[0]=pPtr[2*pointId]*vPtr[3*vecId]; center[1]=pPtr[2*pointId]*vPtr[3*vecId+1]; center[2]=pPtr[2*pointId]*vPtr[3*vecId+2];
double vec[3]; vec[0]=vPtr[3*vecId+1]; vec[1]=-vPtr[3*vecId]; vec[2]=0.;
double norm=vec[0]*vec[0]+vec[1]*vec[1]+vec[2]*vec[2];
}
mm3->changeSpaceDimension(2);
MCAuto<MEDCouplingUMesh> mm4=mm3->buildSpreadZonesWithPoly();
- const int *conn4=mm4->getNodalConnectivity()->begin();
- const int *connI4=mm4->getNodalConnectivityIndex()->begin();
- int nbOfCells=mm4->getNumberOfCells();
- for(int k=0;k<nbOfCells;k++)
+ const mcIdType *conn4=mm4->getNodalConnectivity()->begin();
+ const mcIdType *connI4=mm4->getNodalConnectivityIndex()->begin();
+ mcIdType nbOfCells=mm4->getNumberOfCells();
+ for(mcIdType k=0;k<nbOfCells;k++)
{
int l=0;
- for(const int *work=conn4+connI4[k]+1;work!=conn4+connI4[k+1];work++,l++)
+ for(const mcIdType *work=conn4+connI4[k]+1;work!=conn4+connI4[k+1];work++,l++)
res->pushBackSilent(idsNodePtr[*work]);
res->pushBackSilent(-1);
}
/*!
* This method computes the normalized vector of the plane and the pos of the point belonging to the plane and the line defined by the vector going
* through origin. The plane is defined by its nodal connectivity [ \b begin, \b end ).
- *
+ *
* \param [in] eps below that value the dot product of 2 vectors is considered as colinears
* \param [in] coords coordinates expected to have 3 components.
* \param [in] begin start of the nodal connectivity of the face.
* \param [out] v the normalized vector of size 3
* \param [out] p the pos of plane
*/
-void MEDCouplingUMesh::ComputeVecAndPtOfFace(double eps, const double *coords, const int *begin, const int *end, double *v, double *p)
+void MEDCouplingUMesh::ComputeVecAndPtOfFace(double eps, const double *coords, const mcIdType *begin, const mcIdType *end, double *v, double *p)
{
std::size_t nbPoints=std::distance(begin,end);
if(nbPoints<3)
* This method tries to obtain a well oriented polyhedron.
* If the algorithm fails, an exception will be thrown.
*/
-void MEDCouplingUMesh::TryToCorrectPolyhedronOrientation(int *begin, int *end, const double *coords)
+void MEDCouplingUMesh::TryToCorrectPolyhedronOrientation(mcIdType *begin, mcIdType *end, const double *coords)
{
- std::list< std::pair<int,int> > edgesOK,edgesFinished;
+ std::list< std::pair<mcIdType,mcIdType> > edgesOK,edgesFinished;
std::size_t nbOfFaces=std::count(begin,end,-1)+1;
std::vector<bool> isPerm(nbOfFaces,false);//field on faces False: I don't know, True : oriented
isPerm[0]=true;
- int *bgFace=begin,*endFace=std::find(begin+1,end,-1);
+ mcIdType *bgFace=begin,*endFace=std::find(begin+1,end,-1);
std::size_t nbOfEdgesInFace=std::distance(bgFace,endFace);
- for(std::size_t l=0;l<nbOfEdgesInFace;l++) { std::pair<int,int> p1(bgFace[l],bgFace[(l+1)%nbOfEdgesInFace]); edgesOK.push_back(p1); }
+ for(std::size_t l=0;l<nbOfEdgesInFace;l++) { std::pair<mcIdType,mcIdType> p1(bgFace[l],bgFace[(l+1)%nbOfEdgesInFace]); edgesOK.push_back(p1); }
//
while(std::find(isPerm.begin(),isPerm.end(),false)!=isPerm.end())
{
bool b;
for(std::size_t j=0;j<nbOfEdgesInFace;j++)
{
- std::pair<int,int> p1(bgFace[j],bgFace[(j+1)%nbOfEdgesInFace]);
- std::pair<int,int> p2(p1.second,p1.first);
+ std::pair<mcIdType,mcIdType> p1(bgFace[j],bgFace[(j+1)%nbOfEdgesInFace]);
+ std::pair<mcIdType,mcIdType> p2(p1.second,p1.first);
bool b1=std::find(edgesOK.begin(),edgesOK.end(),p1)!=edgesOK.end();
bool b2=std::find(edgesOK.begin(),edgesOK.end(),p2)!=edgesOK.end();
if(b1 || b2) { b=b2; isPerm[i]=true; smthChanged++; break; }
}
if(isPerm[i])
- {
+ {
if(!b)
std::reverse(bgFace+1,endFace);
for(std::size_t j=0;j<nbOfEdgesInFace;j++)
{
- std::pair<int,int> p1(bgFace[j],bgFace[(j+1)%nbOfEdgesInFace]);
- std::pair<int,int> p2(p1.second,p1.first);
+ std::pair<mcIdType,mcIdType> p1(bgFace[j],bgFace[(j+1)%nbOfEdgesInFace]);
+ std::pair<mcIdType,mcIdType> p2(p1.second,p1.first);
if(std::find(edgesOK.begin(),edgesOK.end(),p1)!=edgesOK.end())
{ std::ostringstream oss; oss << "Face #" << j << " of polyhedron looks bad !"; throw INTERP_KERNEL::Exception(oss.str()); }
if(std::find(edgesFinished.begin(),edgesFinished.end(),p1)!=edgesFinished.end() || std::find(edgesFinished.begin(),edgesFinished.end(),p2)!=edgesFinished.end())
{ std::ostringstream oss; oss << "Face #" << j << " of polyhedron looks bad !"; throw INTERP_KERNEL::Exception(oss.str()); }
- std::list< std::pair<int,int> >::iterator it=std::find(edgesOK.begin(),edgesOK.end(),p2);
+ std::list< std::pair<mcIdType,mcIdType> >::iterator it=std::find(edgesOK.begin(),edgesOK.end(),p2);
if(it!=edgesOK.end())
{
edgesOK.erase(it);
}
if(!edgesOK.empty())
{ throw INTERP_KERNEL::Exception("The polyhedron looks too bad to be repaired : Some edges are shared only once !"); }
- if(INTERP_KERNEL::calculateVolumeForPolyh2<int,INTERP_KERNEL::ALL_C_MODE>(begin,(int)std::distance(begin,end),coords)<-EPS_FOR_POLYH_ORIENTATION)
+ if(INTERP_KERNEL::calculateVolumeForPolyh2<mcIdType,INTERP_KERNEL::ALL_C_MODE>(begin,ToIdType(std::distance(begin,end)),coords)<-EPS_FOR_POLYH_ORIENTATION)
{//not lucky ! The first face was not correctly oriented : reorient all faces...
bgFace=begin;
for(std::size_t i=0;i<nbOfFaces;i++)
/*!
* This method makes the assumption spacedimension == meshdimension == 2.
* This method works only for linear cells.
- *
+ *
* \return a newly allocated array containing the connectivity of a polygon type enum included (NORM_POLYGON in pos#0)
*/
-DataArrayInt *MEDCouplingUMesh::buildUnionOf2DMesh() const
+DataArrayIdType *MEDCouplingUMesh::buildUnionOf2DMesh() const
{
if(getMeshDimension()!=2 || getSpaceDimension()!=2)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::buildUnionOf2DMesh : meshdimension, spacedimension must be equal to 2 !");
MCAuto<MEDCouplingUMesh> skin(computeSkin());
- int oldNbOfNodes(skin->getNumberOfNodes());
- MCAuto<DataArrayInt> o2n(skin->zipCoordsTraducer());
- int nbOfNodesExpected(skin->getNumberOfNodes());
- MCAuto<DataArrayInt> n2o(o2n->invertArrayO2N2N2O(oldNbOfNodes));
- int nbCells(skin->getNumberOfCells());
+ mcIdType oldNbOfNodes(skin->getNumberOfNodes());
+ MCAuto<DataArrayIdType> o2n(skin->zipCoordsTraducer());
+ mcIdType nbOfNodesExpected(skin->getNumberOfNodes());
+ MCAuto<DataArrayIdType> n2o(o2n->invertArrayO2N2N2O(oldNbOfNodes));
+ mcIdType nbCells=skin->getNumberOfCells();
if(nbCells==nbOfNodesExpected)
return buildUnionOf2DMeshLinear(skin,n2o);
else if(2*nbCells==nbOfNodesExpected)
/*!
* This method makes the assumption spacedimension == meshdimension == 3.
* This method works only for linear cells.
- *
+ *
* \return a newly allocated array containing the connectivity of a polygon type enum included (NORM_POLYHED in pos#0)
*/
-DataArrayInt *MEDCouplingUMesh::buildUnionOf3DMesh() const
+DataArrayIdType *MEDCouplingUMesh::buildUnionOf3DMesh() const
{
if(getMeshDimension()!=3 || getSpaceDimension()!=3)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::buildUnionOf3DMesh : meshdimension, spacedimension must be equal to 2 !");
MCAuto<MEDCouplingUMesh> m=computeSkin();
- const int *conn=m->getNodalConnectivity()->begin();
- const int *connI=m->getNodalConnectivityIndex()->begin();
- int nbOfCells=m->getNumberOfCells();
- MCAuto<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(m->getNodalConnectivity()->getNumberOfTuples(),1);
- int *work=ret->getPointer(); *work++=INTERP_KERNEL::NORM_POLYHED;
+ const mcIdType *conn=m->getNodalConnectivity()->begin();
+ const mcIdType *connI=m->getNodalConnectivityIndex()->begin();
+ mcIdType nbOfCells=m->getNumberOfCells();
+ MCAuto<DataArrayIdType> ret=DataArrayIdType::New(); ret->alloc(m->getNodalConnectivity()->getNumberOfTuples(),1);
+ mcIdType *work=ret->getPointer(); *work++=INTERP_KERNEL::NORM_POLYHED;
if(nbOfCells<1)
return ret.retn();
work=std::copy(conn+connI[0]+1,conn+connI[1],work);
- for(int i=1;i<nbOfCells;i++)
+ for(mcIdType i=1;i<nbOfCells;i++)
{
*work++=-1;
work=std::copy(conn+connI[i]+1,conn+connI[i+1],work);
checkConnectivityFullyDefined();
int meshDim = this->getMeshDimension();
- MEDCoupling::DataArrayInt* indexr=MEDCoupling::DataArrayInt::New();
- MEDCoupling::DataArrayInt* revConn=MEDCoupling::DataArrayInt::New();
+ MEDCoupling::DataArrayIdType* indexr=MEDCoupling::DataArrayIdType::New();
+ MEDCoupling::DataArrayIdType* revConn=MEDCoupling::DataArrayIdType::New();
this->getReverseNodalConnectivity(revConn,indexr);
- const int* indexr_ptr=indexr->begin();
- const int* revConn_ptr=revConn->begin();
+ const mcIdType* indexr_ptr=indexr->begin();
+ const mcIdType* revConn_ptr=revConn->begin();
- const MEDCoupling::DataArrayInt* index;
- const MEDCoupling::DataArrayInt* conn;
+ const MEDCoupling::DataArrayIdType* index;
+ const MEDCoupling::DataArrayIdType* conn;
conn=this->getNodalConnectivity(); // it includes a type as the 1st element!!!
index=this->getNodalConnectivityIndex();
- int nbCells=this->getNumberOfCells();
- const int* index_ptr=index->begin();
- const int* conn_ptr=conn->begin();
+ mcIdType nbCells=this->getNumberOfCells();
+ const mcIdType* index_ptr=index->begin();
+ const mcIdType* conn_ptr=conn->begin();
//creating graph arcs (cell to cell relations)
//arcs are stored in terms of (index,value) notation
//warning here one node have less than or equal effective number of cell with it
//but cell could have more than effective nodes
//because other equals nodes in other domain (with other global inode)
- std::vector <int> cell2cell_index(nbCells+1,0);
- std::vector <int> cell2cell;
+ std::vector <mcIdType> cell2cell_index(nbCells+1,0);
+ std::vector <mcIdType> cell2cell;
cell2cell.reserve(3*nbCells);
- for (int icell=0; icell<nbCells;icell++)
+ for (mcIdType icell=0; icell<nbCells;icell++)
{
- std::map<int,int > counter;
- for (int iconn=index_ptr[icell]+1; iconn<index_ptr[icell+1];iconn++)
+ std::map<mcIdType,mcIdType > counter;
+ for (mcIdType iconn=index_ptr[icell]+1; iconn<index_ptr[icell+1];iconn++)
{
- int inode=conn_ptr[iconn];
- for (int iconnr=indexr_ptr[inode]; iconnr<indexr_ptr[inode+1];iconnr++)
+ mcIdType inode=conn_ptr[iconn];
+ for (mcIdType iconnr=indexr_ptr[inode]; iconnr<indexr_ptr[inode+1];iconnr++)
{
- int icell2=revConn_ptr[iconnr];
- std::map<int,int>::iterator iter=counter.find(icell2);
+ mcIdType icell2=revConn_ptr[iconnr];
+ std::map<mcIdType,mcIdType>::iterator iter=counter.find(icell2);
if (iter!=counter.end()) (iter->second)++;
else counter.insert(std::make_pair(icell2,1));
}
}
- for (std::map<int,int>::const_iterator iter=counter.begin();
+ for (std::map<mcIdType,mcIdType>::const_iterator iter=counter.begin();
iter!=counter.end(); iter++)
if (iter->second >= meshDim)
{
indexr->decrRef();
revConn->decrRef();
cell2cell_index[0]=0;
- for (int icell=0; icell<nbCells;icell++)
+ for (mcIdType icell=0; icell<nbCells;icell++)
cell2cell_index[icell+1]=cell2cell_index[icell]+cell2cell_index[icell+1];
//filling up index and value to create skylinearray structure
void MEDCouplingUMesh::writeVTKLL(std::ostream& ofs, const std::string& cellData, const std::string& pointData, DataArrayByte *byteData) const
{
- int nbOfCells=getNumberOfCells();
+ mcIdType nbOfCells=getNumberOfCells();
if(nbOfCells<=0)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::writeVTK : the unstructured mesh has no cells !");
ofs << " <" << getVTKDataSetType() << ">\n";
}
ofs << " </Points>\n";
ofs << " <Cells>\n";
- const int *cPtr=_nodal_connec->begin();
- const int *cIPtr=_nodal_connec_index->begin();
- MCAuto<DataArrayInt> faceoffsets=DataArrayInt::New(); faceoffsets->alloc(nbOfCells,1);
- MCAuto<DataArrayInt> types=DataArrayInt::New(); types->alloc(nbOfCells,1);
- MCAuto<DataArrayInt> offsets=DataArrayInt::New(); offsets->alloc(nbOfCells,1);
- MCAuto<DataArrayInt> connectivity=DataArrayInt::New(); connectivity->alloc(_nodal_connec->getNumberOfTuples()-nbOfCells,1);
- int *w1=faceoffsets->getPointer(),*w2=types->getPointer(),*w3=offsets->getPointer(),*w4=connectivity->getPointer();
- int szFaceOffsets=0,szConn=0;
- for(int i=0;i<nbOfCells;i++,w1++,w2++,w3++)
+ const mcIdType *cPtr=_nodal_connec->begin();
+ const mcIdType *cIPtr=_nodal_connec_index->begin();
+ MCAuto<DataArrayIdType> faceoffsets=DataArrayIdType::New(); faceoffsets->alloc(nbOfCells,1);
+ MCAuto<DataArrayIdType> types=DataArrayIdType::New(); types->alloc(nbOfCells,1);
+ MCAuto<DataArrayIdType> offsets=DataArrayIdType::New(); offsets->alloc(nbOfCells,1);
+ MCAuto<DataArrayIdType> connectivity=DataArrayIdType::New(); connectivity->alloc(_nodal_connec->getNumberOfTuples()-nbOfCells,1);
+ mcIdType *w1=faceoffsets->getPointer(),*w2=types->getPointer(),*w3=offsets->getPointer(),*w4=connectivity->getPointer();
+ mcIdType szFaceOffsets=0,szConn=0;
+ for(mcIdType i=0;i<nbOfCells;i++,w1++,w2++,w3++)
{
*w2=cPtr[cIPtr[i]];
if((INTERP_KERNEL::NormalizedCellType)cPtr[cIPtr[i]]!=INTERP_KERNEL::NORM_POLYHED)
}
else
{
- int deltaFaceOffset=cIPtr[i+1]-cIPtr[i]+1;
+ mcIdType deltaFaceOffset=cIPtr[i+1]-cIPtr[i]+1;
*w1=szFaceOffsets+deltaFaceOffset; szFaceOffsets+=deltaFaceOffset;
- std::set<int> c(cPtr+cIPtr[i]+1,cPtr+cIPtr[i+1]); c.erase(-1);
- *w3=szConn+(int)c.size(); szConn+=(int)c.size();
+ std::set<mcIdType> c(cPtr+cIPtr[i]+1,cPtr+cIPtr[i+1]); c.erase(-1);
+ *w3=szConn+ToIdType(c.size()); szConn+=ToIdType(c.size());
w4=std::copy(c.begin(),c.end(),w4);
}
}
types->transformWithIndArr(MEDCOUPLING2VTKTYPETRADUCER,MEDCOUPLING2VTKTYPETRADUCER+INTERP_KERNEL::NORM_MAXTYPE+1);
types->writeVTK(ofs,8,"UInt8","types",byteData);
- offsets->writeVTK(ofs,8,"Int32","offsets",byteData);
+ std::string vtkTypeName = Traits<mcIdType>::VTKReprStr;
+ offsets->writeVTK(ofs,8,vtkTypeName,"offsets",byteData);
if(szFaceOffsets!=0)
{//presence of Polyhedra
connectivity->reAlloc(szConn);
- faceoffsets->writeVTK(ofs,8,"Int32","faceoffsets",byteData);
- MCAuto<DataArrayInt> faces=DataArrayInt::New(); faces->alloc(szFaceOffsets,1);
+ faceoffsets->writeVTK(ofs,8,vtkTypeName,"faceoffsets",byteData);
+ MCAuto<DataArrayIdType> faces=DataArrayIdType::New(); faces->alloc(szFaceOffsets,1);
w1=faces->getPointer();
- for(int i=0;i<nbOfCells;i++)
+ for(mcIdType i=0;i<nbOfCells;i++)
if((INTERP_KERNEL::NormalizedCellType)cPtr[cIPtr[i]]==INTERP_KERNEL::NORM_POLYHED)
{
- int nbFaces=std::count(cPtr+cIPtr[i]+1,cPtr+cIPtr[i+1],-1)+1;
+ mcIdType nbFaces=ToIdType(std::count(cPtr+cIPtr[i]+1,cPtr+cIPtr[i+1],-1))+1;
*w1++=nbFaces;
- const int *w6=cPtr+cIPtr[i]+1,*w5=0;
- for(int j=0;j<nbFaces;j++)
+ const mcIdType *w6=cPtr+cIPtr[i]+1,*w5=0;
+ for(mcIdType j=0;j<nbFaces;j++)
{
w5=std::find(w6,cPtr+cIPtr[i+1],-1);
- *w1++=(int)std::distance(w6,w5);
+ *w1++=ToIdType(std::distance(w6,w5));
w1=std::copy(w6,w5,w1);
w6=w5+1;
}
}
- faces->writeVTK(ofs,8,"Int32","faces",byteData);
+ faces->writeVTK(ofs,8,vtkTypeName,"faces",byteData);
}
- connectivity->writeVTK(ofs,8,"Int32","connectivity",byteData);
+ connectivity->writeVTK(ofs,8,vtkTypeName,"connectivity",byteData);
ofs << " </Cells>\n";
ofs << " </Piece>\n";
ofs << " </" << getVTKDataSetType() << ">\n";
{ stream << std::endl << "Nodal connectivity NOT set !"; return ; }
if(!_nodal_connec_index->isAllocated())
{ stream << std::endl << "Nodal connectivity set but not allocated !"; return ; }
- int lgth=_nodal_connec_index->getNumberOfTuples();
- int cpt=_nodal_connec_index->getNumberOfComponents();
+ mcIdType lgth=_nodal_connec_index->getNumberOfTuples();
+ std::size_t cpt=_nodal_connec_index->getNumberOfComponents();
if(cpt!=1 || lgth<1)
return ;
stream << std::endl << "Number of cells : " << lgth-1 << ".";
* Provides a renumbering of the cells of this (which has to be a piecewise connected 1D line), so that
* the segments of the line are indexed in consecutive order (i.e. cells \a i and \a i+1 are neighbors).
* This doesn't modify the mesh. This method only works using nodal connectivity consideration. Coordinates of nodes are ignored here.
- * The caller is to deal with the resulting DataArrayInt.
+ * The caller is to deal with the resulting DataArrayIdType.
* \throw If the coordinate array is not set.
* \throw If the nodal connectivity of the cells is not defined.
* \throw If m1 is not a mesh of dimension 2, or m1 is not a mesh of dimension 1
* \throw If m2 is not a (piecewise) line (i.e. if a point has more than 2 adjacent segments)
*
- * \sa DataArrayInt::sortEachPairToMakeALinkedList
+ * \sa DataArrayIdType::sortEachPairToMakeALinkedList
*/
-DataArrayInt *MEDCouplingUMesh::orderConsecutiveCells1D() const
+DataArrayIdType *MEDCouplingUMesh::orderConsecutiveCells1D() const
{
checkFullyDefined();
if(getMeshDimension()!=1)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::orderConsecutiveCells1D works on unstructured mesh with meshdim = 1 !");
// Check that this is a line (and not a more complex 1D mesh) - each point is used at most by 2 segments:
- MCAuto<DataArrayInt> _d(DataArrayInt::New()),_dI(DataArrayInt::New());
- MCAuto<DataArrayInt> _rD(DataArrayInt::New()),_rDI(DataArrayInt::New());
+ MCAuto<DataArrayIdType> _d(DataArrayIdType::New()),_dI(DataArrayIdType::New());
+ MCAuto<DataArrayIdType> _rD(DataArrayIdType::New()),_rDI(DataArrayIdType::New());
MCAuto<MEDCouplingUMesh> m_points(buildDescendingConnectivity(_d, _dI, _rD, _rDI));
- const int *d(_d->begin()), *dI(_dI->begin());
- const int *rD(_rD->begin()), *rDI(_rDI->begin());
- MCAuto<DataArrayInt> _dsi(_rDI->deltaShiftIndex());
- const int * dsi(_dsi->begin());
- MCAuto<DataArrayInt> dsii = _dsi->findIdsNotInRange(0,3);
+ const mcIdType *d(_d->begin()), *dI(_dI->begin());
+ const mcIdType *rD(_rD->begin()), *rDI(_rDI->begin());
+ MCAuto<DataArrayIdType> _dsi(_rDI->deltaShiftIndex());
+ const mcIdType * dsi(_dsi->begin());
+ MCAuto<DataArrayIdType> dsii = _dsi->findIdsNotInRange(0,3);
m_points=0;
if (dsii->getNumberOfTuples())
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::orderConsecutiveCells1D only work with a mesh being a (piecewise) connected line!");
- int nc(getNumberOfCells());
- MCAuto<DataArrayInt> result(DataArrayInt::New());
+ mcIdType nc=getNumberOfCells();
+ MCAuto<DataArrayIdType> result(DataArrayIdType::New());
result->alloc(nc,1);
// set of edges not used so far
- std::set<int> edgeSet;
- for (int i=0; i<nc; edgeSet.insert(i), i++);
+ std::set<mcIdType> edgeSet;
+ for (mcIdType i=0; i<nc; edgeSet.insert(i), i++);
- int startSeg=0;
- int newIdx=0;
+ mcIdType startSeg=0;
+ mcIdType newIdx=0;
// while we have points with only one neighbor segments
do
{
- std::list<int> linePiece;
+ std::list<mcIdType> linePiece;
// fills a list of consecutive segment linked to startSeg. This can go forward or backward.
for (int direction=0;direction<2;direction++) // direction=0 --> forward, direction=1 --> backward
{
// Fill the list forward (resp. backward) from the start segment:
- int activeSeg = startSeg;
- int prevPointId = -20;
- int ptId;
+ mcIdType activeSeg = startSeg;
+ mcIdType prevPointId = -20;
+ mcIdType ptId;
while (!edgeSet.empty())
{
if (!(direction == 1 && prevPointId==-20)) // prevent adding twice startSeg
edgeSet.erase(activeSeg);
}
- int ptId1 = d[dI[activeSeg]], ptId2 = d[dI[activeSeg]+1];
+ mcIdType ptId1 = d[dI[activeSeg]], ptId2 = d[dI[activeSeg]+1];
ptId = direction ? (ptId1 == prevPointId ? ptId2 : ptId1) : (ptId2 == prevPointId ? ptId1 : ptId2);
if (dsi[ptId] == 1) // hitting the end of the line
break;
prevPointId = ptId;
- int seg1 = rD[rDI[ptId]], seg2 = rD[rDI[ptId]+1];
+ mcIdType seg1 = rD[rDI[ptId]], seg2 = rD[rDI[ptId]+1];
activeSeg = (seg1 == activeSeg) ? seg2 : seg1;
}
}
// Done, save final piece into DA:
std::copy(linePiece.begin(), linePiece.end(), result->getPointer()+newIdx);
- newIdx += linePiece.size();
+ newIdx += ToIdType(linePiece.size());
// identify next valid start segment (one which is not consumed)
if(!edgeSet.empty())
* \b WARNING : is returned value is different from 0 a call to MEDCouplingUMesh::mergeNodes is necessary to
* avoid to have a non conform mesh.
*
- * \return int - the number of new nodes created (in most of cases 0).
- *
+ * \return mcIdType - the number of new nodes created (in most of cases 0).
+ *
* \throw If \a this is not coherent.
* \throw If \a this has not spaceDim equal to 2.
* \throw If \a this has not meshDim equal to 2.
* \throw If some subcells needed to be split are orphan.
* \sa MEDCouplingUMesh::conformize2D
*/
-int MEDCouplingUMesh::split2DCells(const DataArrayInt *desc, const DataArrayInt *descI, const DataArrayInt *subNodesInSeg, const DataArrayInt *subNodesInSegI, const DataArrayInt *midOpt, const DataArrayInt *midOptI)
+mcIdType MEDCouplingUMesh::split2DCells(const DataArrayIdType *desc, const DataArrayIdType *descI, const DataArrayIdType *subNodesInSeg, const DataArrayIdType *subNodesInSegI, const DataArrayIdType *midOpt, const DataArrayIdType *midOptI)
{
if(!desc || !descI || !subNodesInSeg || !subNodesInSegI)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::split2DCells : the 4 first arrays must be not null !");
* the geometric cell type set to INTERP_KERNEL::NORM_POLYGON.
* This method excepts that \b coords parameter is expected to be in dimension 2. [ \b nodalConnBg , \b nodalConnEnd ) is the nodal connectivity of the input
* cell (geometric cell type included at the position 0). If the meshdimension of the input cell is not equal to 2 an INTERP_KERNEL::Exception will be thrown.
- *
+ *
* \return false if the input connectivity represents already the convex hull, true if the input cell needs to be reordered.
*/
-bool MEDCouplingUMesh::BuildConvexEnvelopOf2DCellJarvis(const double *coords, const int *nodalConnBg, const int *nodalConnEnd, DataArrayInt *nodalConnecOut)
+bool MEDCouplingUMesh::BuildConvexEnvelopOf2DCellJarvis(const double *coords, const mcIdType *nodalConnBg, const mcIdType *nodalConnEnd, DataArrayIdType *nodalConnecOut)
{
std::size_t sz=std::distance(nodalConnBg,nodalConnEnd);
if(sz>=4)
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel((INTERP_KERNEL::NormalizedCellType)*nodalConnBg);
if(cm.getDimension()==2)
{
- const int *node=nodalConnBg+1;
- int startNode=*node++;
+ const mcIdType *node=nodalConnBg+1;
+ mcIdType startNode=*node++;
double refX=coords[2*startNode];
for(;node!=nodalConnEnd;node++)
{
refX=coords[2*startNode];
}
}
- std::vector<int> tmpOut; tmpOut.reserve(sz); tmpOut.push_back(startNode);
+ std::vector<mcIdType> tmpOut; tmpOut.reserve(sz); tmpOut.push_back(startNode);
refX=1e300;
double tmp1;
double tmp2[2];
double angle0=-M_PI/2;
//
- int nextNode=-1;
- int prevNode=-1;
+ mcIdType nextNode=-1;
+ mcIdType prevNode=-1;
double resRef;
double angleNext=0.;
while(nextNode!=startNode)
tmpOut.push_back(nextNode);
}
}
- std::vector<int> tmp3(2*(sz-1));
- std::vector<int>::iterator it=std::copy(nodalConnBg+1,nodalConnEnd,tmp3.begin());
+ std::vector<mcIdType> tmp3(2*(sz-1));
+ std::vector<mcIdType>::iterator it=std::copy(nodalConnBg+1,nodalConnEnd,tmp3.begin());
std::copy(nodalConnBg+1,nodalConnEnd,it);
if(std::search(tmp3.begin(),tmp3.end(),tmpOut.begin(),tmpOut.end())!=tmp3.end())
{
}
else
{
- nodalConnecOut->pushBackSilent((int)INTERP_KERNEL::NORM_POLYGON);
+ nodalConnecOut->pushBackSilent(ToIdType(INTERP_KERNEL::NORM_POLYGON));
nodalConnecOut->insertAtTheEnd(tmpOut.begin(),tmpOut.end());
return true;
}
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::BuildConvexEnvelopOf2DCellJarvis : invalid 2D cell connectivity !");
}
-/*!
- * This method works on an input pair (\b arr, \b arrIndx) where \b arr indexes is in \b arrIndx.
- * This method will not impact the size of inout parameter \b arrIndx but the size of \b arr will be modified in case of suppression.
- *
- * \param [in] idsToRemoveBg begin of set of ids to remove in \b arr (included)
- * \param [in] idsToRemoveEnd end of set of ids to remove in \b arr (excluded)
- * \param [in,out] arr array in which the remove operation will be done.
- * \param [in,out] arrIndx array in the remove operation will modify
- * \param [in] offsetForRemoval (by default 0) offset so that for each i in [0,arrIndx->getNumberOfTuples()-1) removal process will be performed in the following range [arr+arrIndx[i]+offsetForRemoval,arr+arr[i+1])
- * \return true if \b arr and \b arrIndx have been modified, false if not.
- */
-bool MEDCouplingUMesh::RemoveIdsFromIndexedArrays(const int *idsToRemoveBg, const int *idsToRemoveEnd, DataArrayInt *arr, DataArrayInt *arrIndx, int offsetForRemoval)
-{
- if(!arrIndx || !arr)
- throw INTERP_KERNEL::Exception("MEDCouplingUMesh::RemoveIdsFromIndexedArrays : some input arrays are empty !");
- if(offsetForRemoval<0)
- throw INTERP_KERNEL::Exception("MEDCouplingUMesh::RemoveIdsFromIndexedArrays : offsetForRemoval should be >=0 !");
- std::set<int> s(idsToRemoveBg,idsToRemoveEnd);
- int nbOfGrps=arrIndx->getNumberOfTuples()-1;
- int *arrIPtr=arrIndx->getPointer();
- *arrIPtr++=0;
- int previousArrI=0;
- const int *arrPtr=arr->begin();
- std::vector<int> arrOut;//no utility to switch to DataArrayInt because copy always needed
- for(int i=0;i<nbOfGrps;i++,arrIPtr++)
- {
- if(*arrIPtr-previousArrI>offsetForRemoval)
- {
- for(const int *work=arrPtr+previousArrI+offsetForRemoval;work!=arrPtr+*arrIPtr;work++)
- {
- if(s.find(*work)==s.end())
- arrOut.push_back(*work);
- }
- }
- previousArrI=*arrIPtr;
- *arrIPtr=(int)arrOut.size();
- }
- if(arr->getNumberOfTuples()==arrOut.size())
- return false;
- arr->alloc((int)arrOut.size(),1);
- std::copy(arrOut.begin(),arrOut.end(),arr->getPointer());
- return true;
-}
-
-/*!
- * This method works on a pair input (\b arrIn, \b arrIndxIn) where \b arrIn indexes is in \b arrIndxIn
- * (\ref numbering-indirect).
- * This method returns the result of the extraction ( specified by a set of ids in [\b idsOfSelectBg , \b idsOfSelectEnd ) ).
- * The selection of extraction is done standardly in new2old format.
- * This method returns indexed arrays (\ref numbering-indirect) using 2 arrays (arrOut,arrIndexOut).
- *
- * \param [in] idsOfSelectBg begin of set of ids of the input extraction (included)
- * \param [in] idsOfSelectEnd end of set of ids of the input extraction (excluded)
- * \param [in] arrIn arr origin array from which the extraction will be done.
- * \param [in] arrIndxIn is the input index array allowing to walk into \b arrIn
- * \param [out] arrOut the resulting array
- * \param [out] arrIndexOut the index array of the resulting array \b arrOut
- * \sa MEDCouplingUMesh::ExtractFromIndexedArraysSlice
- */
-void MEDCouplingUMesh::ExtractFromIndexedArrays(const int *idsOfSelectBg, const int *idsOfSelectEnd, const DataArrayInt *arrIn, const DataArrayInt *arrIndxIn,
- DataArrayInt* &arrOut, DataArrayInt* &arrIndexOut)
-{
- if(!arrIn || !arrIndxIn)
- throw INTERP_KERNEL::Exception("MEDCouplingUMesh::ExtractFromIndexedArrays : input pointer is NULL !");
- arrIn->checkAllocated(); arrIndxIn->checkAllocated();
- if(arrIn->getNumberOfComponents()!=1 || arrIndxIn->getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("MEDCouplingUMesh::ExtractFromIndexedArrays : input arrays must have exactly one component !");
- std::size_t sz=std::distance(idsOfSelectBg,idsOfSelectEnd);
- const int *arrInPtr=arrIn->begin();
- const int *arrIndxPtr=arrIndxIn->begin();
- int nbOfGrps=arrIndxIn->getNumberOfTuples()-1;
- if(nbOfGrps<0)
- throw INTERP_KERNEL::Exception("MEDCouplingUMesh::ExtractFromIndexedArrays : The format of \"arrIndxIn\" is invalid ! Its nb of tuples should be >=1 !");
- int maxSizeOfArr=arrIn->getNumberOfTuples();
- MCAuto<DataArrayInt> arro=DataArrayInt::New();
- MCAuto<DataArrayInt> arrIo=DataArrayInt::New();
- arrIo->alloc((int)(sz+1),1);
- const int *idsIt=idsOfSelectBg;
- int *work=arrIo->getPointer();
- *work++=0;
- int lgth=0;
- for(std::size_t i=0;i<sz;i++,work++,idsIt++)
- {
- if(*idsIt>=0 && *idsIt<nbOfGrps)
- lgth+=arrIndxPtr[*idsIt+1]-arrIndxPtr[*idsIt];
- else
- {
- std::ostringstream oss; oss << "MEDCouplingUMesh::ExtractFromIndexedArrays : id located on pos #" << i << " value is " << *idsIt << " ! Must be in [0," << nbOfGrps << ") !";
- throw INTERP_KERNEL::Exception(oss.str());
- }
- if(lgth>=work[-1])
- *work=lgth;
- else
- {
- std::ostringstream oss; oss << "MEDCouplingUMesh::ExtractFromIndexedArrays : id located on pos #" << i << " value is " << *idsIt << " and at this pos arrIndxIn[" << *idsIt;
- oss << "+1]-arrIndxIn[" << *idsIt << "] < 0 ! The input index array is bugged !";
- throw INTERP_KERNEL::Exception(oss.str());
- }
- }
- arro->alloc(lgth,1);
- work=arro->getPointer();
- idsIt=idsOfSelectBg;
- for(std::size_t i=0;i<sz;i++,idsIt++)
- {
- if(arrIndxPtr[*idsIt]>=0 && arrIndxPtr[*idsIt+1]<=maxSizeOfArr)
- work=std::copy(arrInPtr+arrIndxPtr[*idsIt],arrInPtr+arrIndxPtr[*idsIt+1],work);
- else
- {
- std::ostringstream oss; oss << "MEDCouplingUMesh::ExtractFromIndexedArrays : id located on pos #" << i << " value is " << *idsIt << " arrIndx[" << *idsIt << "] must be >= 0 and arrIndx[";
- oss << *idsIt << "+1] <= " << maxSizeOfArr << " (the size of arrIn)!";
- throw INTERP_KERNEL::Exception(oss.str());
- }
- }
- arrOut=arro.retn();
- arrIndexOut=arrIo.retn();
-}
-
-/*!
- * This method works on a pair input (\b arrIn, \b arrIndxIn) where \b arrIn indexes is in \b arrIndxIn
- * (\ref numbering-indirect).
- * This method returns the result of the extraction ( specified by a set of ids with a slice given by \a idsOfSelectStart, \a idsOfSelectStop and \a idsOfSelectStep ).
- * The selection of extraction is done standardly in new2old format.
- * This method returns indexed arrays (\ref numbering-indirect) using 2 arrays (arrOut,arrIndexOut).
- *
- * \param [in] idsOfSelectStart begin of set of ids of the input extraction (included)
- * \param [in] idsOfSelectStop end of set of ids of the input extraction (excluded)
- * \param [in] idsOfSelectStep
- * \param [in] arrIn arr origin array from which the extraction will be done.
- * \param [in] arrIndxIn is the input index array allowing to walk into \b arrIn
- * \param [out] arrOut the resulting array
- * \param [out] arrIndexOut the index array of the resulting array \b arrOut
- * \sa MEDCouplingUMesh::ExtractFromIndexedArrays
- */
-void MEDCouplingUMesh::ExtractFromIndexedArraysSlice(int idsOfSelectStart, int idsOfSelectStop, int idsOfSelectStep, const DataArrayInt *arrIn, const DataArrayInt *arrIndxIn,
- DataArrayInt* &arrOut, DataArrayInt* &arrIndexOut)
-{
- if(!arrIn || !arrIndxIn)
- throw INTERP_KERNEL::Exception("MEDCouplingUMesh::ExtractFromIndexedArraysSlice : input pointer is NULL !");
- arrIn->checkAllocated(); arrIndxIn->checkAllocated();
- if(arrIn->getNumberOfComponents()!=1 || arrIndxIn->getNumberOfComponents()!=1)
- throw INTERP_KERNEL::Exception("MEDCouplingUMesh::ExtractFromIndexedArraysSlice : input arrays must have exactly one component !");
- int sz=DataArrayInt::GetNumberOfItemGivenBESRelative(idsOfSelectStart,idsOfSelectStop,idsOfSelectStep,"MEDCouplingUMesh::ExtractFromIndexedArraysSlice : Input slice ");
- const int *arrInPtr=arrIn->begin();
- const int *arrIndxPtr=arrIndxIn->begin();
- int nbOfGrps=arrIndxIn->getNumberOfTuples()-1;
- if(nbOfGrps<0)
- throw INTERP_KERNEL::Exception("MEDCouplingUMesh::ExtractFromIndexedArraysSlice : The format of \"arrIndxIn\" is invalid ! Its nb of tuples should be >=1 !");
- int maxSizeOfArr=arrIn->getNumberOfTuples();
- MCAuto<DataArrayInt> arro=DataArrayInt::New();
- MCAuto<DataArrayInt> arrIo=DataArrayInt::New();
- arrIo->alloc((int)(sz+1),1);
- int idsIt=idsOfSelectStart;
- int *work=arrIo->getPointer();
- *work++=0;
- int lgth=0;
- for(int i=0;i<sz;i++,work++,idsIt+=idsOfSelectStep)
- {
- if(idsIt>=0 && idsIt<nbOfGrps)
- lgth+=arrIndxPtr[idsIt+1]-arrIndxPtr[idsIt];
- else
- {
- std::ostringstream oss; oss << "MEDCouplingUMesh::ExtractFromIndexedArraysSlice : id located on pos #" << i << " value is " << idsIt << " ! Must be in [0," << nbOfGrps << ") !";
- throw INTERP_KERNEL::Exception(oss.str());
- }
- if(lgth>=work[-1])
- *work=lgth;
- else
- {
- std::ostringstream oss; oss << "MEDCouplingUMesh::ExtractFromIndexedArraysSlice : id located on pos #" << i << " value is " << idsIt << " and at this pos arrIndxIn[" << idsIt;
- oss << "+1]-arrIndxIn[" << idsIt << "] < 0 ! The input index array is bugged !";
- throw INTERP_KERNEL::Exception(oss.str());
- }
- }
- arro->alloc(lgth,1);
- work=arro->getPointer();
- idsIt=idsOfSelectStart;
- for(int i=0;i<sz;i++,idsIt+=idsOfSelectStep)
- {
- if(arrIndxPtr[idsIt]>=0 && arrIndxPtr[idsIt+1]<=maxSizeOfArr)
- work=std::copy(arrInPtr+arrIndxPtr[idsIt],arrInPtr+arrIndxPtr[idsIt+1],work);
- else
- {
- std::ostringstream oss; oss << "MEDCouplingUMesh::ExtractFromIndexedArraysSlice : id located on pos #" << i << " value is " << idsIt << " arrIndx[" << idsIt << "] must be >= 0 and arrIndx[";
- oss << idsIt << "+1] <= " << maxSizeOfArr << " (the size of arrIn)!";
- throw INTERP_KERNEL::Exception(oss.str());
- }
- }
- arrOut=arro.retn();
- arrIndexOut=arrIo.retn();
-}
-
-/*!
- * This method works on an input pair (\b arrIn, \b arrIndxIn) where \b arrIn indexes is in \b arrIndxIn.
- * This method builds an output pair (\b arrOut,\b arrIndexOut) that is a copy from \b arrIn for all cell ids \b not \b in [ \b idsOfSelectBg , \b idsOfSelectEnd ) and for
- * cellIds \b in [ \b idsOfSelectBg , \b idsOfSelectEnd ) a copy coming from the corresponding values in input pair (\b srcArr, \b srcArrIndex).
- * This method is an generalization of MEDCouplingUMesh::SetPartOfIndexedArraysSameIdx that performs the same thing but by without building explicitly a result output arrays.
- *
- * \param [in] idsOfSelectBg begin of set of ids of the input extraction (included)
- * \param [in] idsOfSelectEnd end of set of ids of the input extraction (excluded)
- * \param [in] arrIn arr origin array from which the extraction will be done.
- * \param [in] arrIndxIn is the input index array allowing to walk into \b arrIn
- * \param [in] srcArr input array that will be used as source of copy for ids in [ \b idsOfSelectBg, \b idsOfSelectEnd )
- * \param [in] srcArrIndex index array of \b srcArr
- * \param [out] arrOut the resulting array
- * \param [out] arrIndexOut the index array of the resulting array \b arrOut
- *
- * \sa MEDCouplingUMesh::SetPartOfIndexedArraysSameIdx
- */
-void MEDCouplingUMesh::SetPartOfIndexedArrays(const int *idsOfSelectBg, const int *idsOfSelectEnd, const DataArrayInt *arrIn, const DataArrayInt *arrIndxIn,
- const DataArrayInt *srcArr, const DataArrayInt *srcArrIndex,
- DataArrayInt* &arrOut, DataArrayInt* &arrIndexOut)
-{
- if(arrIn==0 || arrIndxIn==0 || srcArr==0 || srcArrIndex==0)
- throw INTERP_KERNEL::Exception("MEDCouplingUMesh::SetPartOfIndexedArrays : presence of null pointer in input parameter !");
- MCAuto<DataArrayInt> arro=DataArrayInt::New();
- MCAuto<DataArrayInt> arrIo=DataArrayInt::New();
- int nbOfTuples=arrIndxIn->getNumberOfTuples()-1;
- std::vector<bool> v(nbOfTuples,true);
- int offset=0;
- const int *arrIndxInPtr=arrIndxIn->begin();
- const int *srcArrIndexPtr=srcArrIndex->begin();
- for(const int *it=idsOfSelectBg;it!=idsOfSelectEnd;it++,srcArrIndexPtr++)
- {
- if(*it>=0 && *it<nbOfTuples)
- {
- v[*it]=false;
- offset+=(srcArrIndexPtr[1]-srcArrIndexPtr[0])-(arrIndxInPtr[*it+1]-arrIndxInPtr[*it]);
- }
- else
- {
- std::ostringstream oss; oss << "MEDCouplingUMesh::SetPartOfIndexedArrays : On pos #" << std::distance(idsOfSelectBg,it) << " value is " << *it << " not in [0," << nbOfTuples << ") !";
- throw INTERP_KERNEL::Exception(oss.str());
- }
- }
- srcArrIndexPtr=srcArrIndex->begin();
- arrIo->alloc(nbOfTuples+1,1);
- arro->alloc(arrIn->getNumberOfTuples()+offset,1);
- const int *arrInPtr=arrIn->begin();
- const int *srcArrPtr=srcArr->begin();
- int *arrIoPtr=arrIo->getPointer(); *arrIoPtr++=0;
- int *arroPtr=arro->getPointer();
- for(int ii=0;ii<nbOfTuples;ii++,arrIoPtr++)
- {
- if(v[ii])
- {
- arroPtr=std::copy(arrInPtr+arrIndxInPtr[ii],arrInPtr+arrIndxInPtr[ii+1],arroPtr);
- *arrIoPtr=arrIoPtr[-1]+(arrIndxInPtr[ii+1]-arrIndxInPtr[ii]);
- }
- else
- {
- std::size_t pos=std::distance(idsOfSelectBg,std::find(idsOfSelectBg,idsOfSelectEnd,ii));
- arroPtr=std::copy(srcArrPtr+srcArrIndexPtr[pos],srcArrPtr+srcArrIndexPtr[pos+1],arroPtr);
- *arrIoPtr=arrIoPtr[-1]+(srcArrIndexPtr[pos+1]-srcArrIndexPtr[pos]);
- }
- }
- arrOut=arro.retn();
- arrIndexOut=arrIo.retn();
-}
-
-/*!
- * This method works on an input pair (\b arrIn, \b arrIndxIn) where \b arrIn indexes is in \b arrIndxIn.
- * This method is an specialization of MEDCouplingUMesh::SetPartOfIndexedArrays in the case of assignment do not modify the index in \b arrIndxIn.
- *
- * \param [in] idsOfSelectBg begin of set of ids of the input extraction (included)
- * \param [in] idsOfSelectEnd end of set of ids of the input extraction (excluded)
- * \param [in,out] arrInOut arr origin array from which the extraction will be done.
- * \param [in] arrIndxIn is the input index array allowing to walk into \b arrIn
- * \param [in] srcArr input array that will be used as source of copy for ids in [ \b idsOfSelectBg , \b idsOfSelectEnd )
- * \param [in] srcArrIndex index array of \b srcArr
- *
- * \sa MEDCouplingUMesh::SetPartOfIndexedArrays
- */
-void MEDCouplingUMesh::SetPartOfIndexedArraysSameIdx(const int *idsOfSelectBg, const int *idsOfSelectEnd, DataArrayInt *arrInOut, const DataArrayInt *arrIndxIn,
- const DataArrayInt *srcArr, const DataArrayInt *srcArrIndex)
-{
- if(arrInOut==0 || arrIndxIn==0 || srcArr==0 || srcArrIndex==0)
- throw INTERP_KERNEL::Exception("MEDCouplingUMesh::SetPartOfIndexedArraysSameIdx : presence of null pointer in input parameter !");
- int nbOfTuples=arrIndxIn->getNumberOfTuples()-1;
- const int *arrIndxInPtr=arrIndxIn->begin();
- const int *srcArrIndexPtr=srcArrIndex->begin();
- int *arrInOutPtr=arrInOut->getPointer();
- const int *srcArrPtr=srcArr->begin();
- for(const int *it=idsOfSelectBg;it!=idsOfSelectEnd;it++,srcArrIndexPtr++)
- {
- if(*it>=0 && *it<nbOfTuples)
- {
- if(srcArrIndexPtr[1]-srcArrIndexPtr[0]==arrIndxInPtr[*it+1]-arrIndxInPtr[*it])
- std::copy(srcArrPtr+srcArrIndexPtr[0],srcArrPtr+srcArrIndexPtr[1],arrInOutPtr+arrIndxInPtr[*it]);
- else
- {
- std::ostringstream oss; oss << "MEDCouplingUMesh::SetPartOfIndexedArraysSameIdx : On pos #" << std::distance(idsOfSelectBg,it) << " id (idsOfSelectBg[" << std::distance(idsOfSelectBg,it)<< "]) is " << *it << " arrIndxIn[id+1]-arrIndxIn[id]!=srcArrIndex[pos+1]-srcArrIndex[pos] !";
- throw INTERP_KERNEL::Exception(oss.str());
- }
- }
- else
- {
- std::ostringstream oss; oss << "MEDCouplingUMesh::SetPartOfIndexedArraysSameIdx : On pos #" << std::distance(idsOfSelectBg,it) << " value is " << *it << " not in [0," << nbOfTuples << ") !";
- throw INTERP_KERNEL::Exception(oss.str());
- }
- }
-}
-
/*!
* This method works on a pair input (\b arrIn, \b arrIndxIn) where \b arr indexes is in \b arrIndxIn.
* This method expects that these two input arrays come from the output of MEDCouplingUMesh::computeNeighborsOfCells method.
- * This method start from id 0 that will be contained in output DataArrayInt. It searches then all neighbors of id0 looking at arrIn[arrIndxIn[0]:arrIndxIn[0+1]].
+ * This method start from id 0 that will be contained in output DataArrayIdType. It searches then all neighbors of id0 looking at arrIn[arrIndxIn[0]:arrIndxIn[0+1]].
* Then it is repeated recursively until either all ids are fetched or no more ids are reachable step by step.
* A negative value in \b arrIn means that it is ignored.
* This method is useful to see if a mesh is contiguous regarding its connectivity. If it is not the case the size of returned array is different from arrIndxIn->getNumberOfTuples()-1.
- *
+ *
* \param [in] arrIn arr origin array from which the extraction will be done.
* \param [in] arrIndxIn is the input index array allowing to walk into \b arrIn
* \return a newly allocated DataArray that stores all ids fetched by the gradually spread process.
* \sa MEDCouplingUMesh::ComputeSpreadZoneGraduallyFromSeed, MEDCouplingUMesh::partitionBySpreadZone
*/
-DataArrayInt *MEDCouplingUMesh::ComputeSpreadZoneGradually(const DataArrayInt *arrIn, const DataArrayInt *arrIndxIn)
+DataArrayIdType *MEDCouplingUMesh::ComputeSpreadZoneGradually(const DataArrayIdType *arrIn, const DataArrayIdType *arrIndxIn)
{
- int seed=0,nbOfDepthPeelingPerformed=0;
+ mcIdType seed=0,nbOfDepthPeelingPerformed=0;
return ComputeSpreadZoneGraduallyFromSeed(&seed,&seed+1,arrIn,arrIndxIn,-1,nbOfDepthPeelingPerformed);
}
/*!
* This method works on a pair input (\b arrIn, \b arrIndxIn) where \b arr indexes is in \b arrIndxIn.
* This method expects that these two input arrays come from the output of MEDCouplingUMesh::computeNeighborsOfCells method.
- * This method start from id 0 that will be contained in output DataArrayInt. It searches then all neighbors of id0 regarding arrIn[arrIndxIn[0]:arrIndxIn[0+1]].
+ * This method start from id 0 that will be contained in output DataArrayIdType. It searches then all neighbors of id0 regarding arrIn[arrIndxIn[0]:arrIndxIn[0+1]].
* Then it is repeated recursively until either all ids are fetched or no more ids are reachable step by step.
* A negative value in \b arrIn means that it is ignored.
* This method is useful to see if a mesh is contiguous regarding its connectivity. If it is not the case the size of returned array is different from arrIndxIn->getNumberOfTuples()-1.
* \return a newly allocated DataArray that stores all ids fetched by the gradually spread process.
* \sa MEDCouplingUMesh::partitionBySpreadZone
*/
-DataArrayInt *MEDCouplingUMesh::ComputeSpreadZoneGraduallyFromSeed(const int *seedBg, const int *seedEnd, const DataArrayInt *arrIn, const DataArrayInt *arrIndxIn, int nbOfDepthPeeling, int& nbOfDepthPeelingPerformed)
+DataArrayIdType *MEDCouplingUMesh::ComputeSpreadZoneGraduallyFromSeed(const mcIdType *seedBg, const mcIdType *seedEnd, const DataArrayIdType *arrIn, const DataArrayIdType *arrIndxIn, mcIdType nbOfDepthPeeling, mcIdType& nbOfDepthPeelingPerformed)
{
nbOfDepthPeelingPerformed=0;
if(!arrIndxIn)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::ComputeSpreadZoneGraduallyFromSeed : arrIndxIn input pointer is NULL !");
- int nbOfTuples=arrIndxIn->getNumberOfTuples()-1;
+ mcIdType nbOfTuples=arrIndxIn->getNumberOfTuples()-1;
if(nbOfTuples<=0)
{
- DataArrayInt *ret=DataArrayInt::New(); ret->alloc(0,1);
+ DataArrayIdType *ret=DataArrayIdType::New(); ret->alloc(0,1);
return ret;
}
//
}
-/*!
- * This method works on an input pair (\b arrIn, \b arrIndxIn) where \b arrIn indexes is in \b arrIndxIn.
- * This method builds an output pair (\b arrOut,\b arrIndexOut) that is a copy from \b arrIn for all cell ids \b not \b in [ \b idsOfSelectBg , \b idsOfSelectEnd ) and for
- * cellIds \b in [\b idsOfSelectBg, \b idsOfSelectEnd) a copy coming from the corresponding values in input pair (\b srcArr, \b srcArrIndex).
- * This method is an generalization of MEDCouplingUMesh::SetPartOfIndexedArraysSameIdx that performs the same thing but by without building explicitly a result output arrays.
- *
- * \param [in] start begin of set of ids of the input extraction (included)
- * \param [in] end end of set of ids of the input extraction (excluded)
- * \param [in] step step of the set of ids in range mode.
- * \param [in] arrIn arr origin array from which the extraction will be done.
- * \param [in] arrIndxIn is the input index array allowing to walk into \b arrIn
- * \param [in] srcArr input array that will be used as source of copy for ids in [\b idsOfSelectBg, \b idsOfSelectEnd)
- * \param [in] srcArrIndex index array of \b srcArr
- * \param [out] arrOut the resulting array
- * \param [out] arrIndexOut the index array of the resulting array \b arrOut
- *
- * \sa MEDCouplingUMesh::SetPartOfIndexedArraysSameIdx MEDCouplingUMesh::SetPartOfIndexedArrays
- */
-void MEDCouplingUMesh::SetPartOfIndexedArraysSlice(int start, int end, int step, const DataArrayInt *arrIn, const DataArrayInt *arrIndxIn,
- const DataArrayInt *srcArr, const DataArrayInt *srcArrIndex,
- DataArrayInt* &arrOut, DataArrayInt* &arrIndexOut)
-{
- if(arrIn==0 || arrIndxIn==0 || srcArr==0 || srcArrIndex==0)
- throw INTERP_KERNEL::Exception("MEDCouplingUMesh::SetPartOfIndexedArraysSlice : presence of null pointer in input parameter !");
- MCAuto<DataArrayInt> arro=DataArrayInt::New();
- MCAuto<DataArrayInt> arrIo=DataArrayInt::New();
- int nbOfTuples=arrIndxIn->getNumberOfTuples()-1;
- int offset=0;
- const int *arrIndxInPtr=arrIndxIn->begin();
- const int *srcArrIndexPtr=srcArrIndex->begin();
- int nbOfElemsToSet=DataArray::GetNumberOfItemGivenBESRelative(start,end,step,"MEDCouplingUMesh::SetPartOfIndexedArraysSlice : ");
- int it=start;
- for(int i=0;i<nbOfElemsToSet;i++,srcArrIndexPtr++,it+=step)
- {
- if(it>=0 && it<nbOfTuples)
- offset+=(srcArrIndexPtr[1]-srcArrIndexPtr[0])-(arrIndxInPtr[it+1]-arrIndxInPtr[it]);
- else
- {
- std::ostringstream oss; oss << "MEDCouplingUMesh::SetPartOfIndexedArraysSlice : On pos #" << i << " value is " << it << " not in [0," << nbOfTuples << ") !";
- throw INTERP_KERNEL::Exception(oss.str());
- }
- }
- srcArrIndexPtr=srcArrIndex->begin();
- arrIo->alloc(nbOfTuples+1,1);
- arro->alloc(arrIn->getNumberOfTuples()+offset,1);
- const int *arrInPtr=arrIn->begin();
- const int *srcArrPtr=srcArr->begin();
- int *arrIoPtr=arrIo->getPointer(); *arrIoPtr++=0;
- int *arroPtr=arro->getPointer();
- for(int ii=0;ii<nbOfTuples;ii++,arrIoPtr++)
- {
- int pos=DataArray::GetPosOfItemGivenBESRelativeNoThrow(ii,start,end,step);
- if(pos<0)
- {
- arroPtr=std::copy(arrInPtr+arrIndxInPtr[ii],arrInPtr+arrIndxInPtr[ii+1],arroPtr);
- *arrIoPtr=arrIoPtr[-1]+(arrIndxInPtr[ii+1]-arrIndxInPtr[ii]);
- }
- else
- {
- arroPtr=std::copy(srcArrPtr+srcArrIndexPtr[pos],srcArrPtr+srcArrIndexPtr[pos+1],arroPtr);
- *arrIoPtr=arrIoPtr[-1]+(srcArrIndexPtr[pos+1]-srcArrIndexPtr[pos]);
- }
- }
- arrOut=arro.retn();
- arrIndexOut=arrIo.retn();
-}
-
-/*!
- * This method works on an input pair (\b arrIn, \b arrIndxIn) where \b arrIn indexes is in \b arrIndxIn.
- * This method is an specialization of MEDCouplingUMesh::SetPartOfIndexedArrays in the case of assignment do not modify the index in \b arrIndxIn.
- *
- * \param [in] start begin of set of ids of the input extraction (included)
- * \param [in] end end of set of ids of the input extraction (excluded)
- * \param [in] step step of the set of ids in range mode.
- * \param [in,out] arrInOut arr origin array from which the extraction will be done.
- * \param [in] arrIndxIn is the input index array allowing to walk into \b arrIn
- * \param [in] srcArr input array that will be used as source of copy for ids in [\b idsOfSelectBg, \b idsOfSelectEnd)
- * \param [in] srcArrIndex index array of \b srcArr
- *
- * \sa MEDCouplingUMesh::SetPartOfIndexedArraysSlice MEDCouplingUMesh::SetPartOfIndexedArraysSameIdx
- */
-void MEDCouplingUMesh::SetPartOfIndexedArraysSameIdxSlice(int start, int end, int step, DataArrayInt *arrInOut, const DataArrayInt *arrIndxIn,
- const DataArrayInt *srcArr, const DataArrayInt *srcArrIndex)
-{
- if(arrInOut==0 || arrIndxIn==0 || srcArr==0 || srcArrIndex==0)
- throw INTERP_KERNEL::Exception("MEDCouplingUMesh::SetPartOfIndexedArraysSameIdxSlice : presence of null pointer in input parameter !");
- int nbOfTuples=arrIndxIn->getNumberOfTuples()-1;
- const int *arrIndxInPtr=arrIndxIn->begin();
- const int *srcArrIndexPtr=srcArrIndex->begin();
- int *arrInOutPtr=arrInOut->getPointer();
- const int *srcArrPtr=srcArr->begin();
- int nbOfElemsToSet=DataArray::GetNumberOfItemGivenBESRelative(start,end,step,"MEDCouplingUMesh::SetPartOfIndexedArraysSameIdxSlice : ");
- int it=start;
- for(int i=0;i<nbOfElemsToSet;i++,srcArrIndexPtr++,it+=step)
- {
- if(it>=0 && it<nbOfTuples)
- {
- if(srcArrIndexPtr[1]-srcArrIndexPtr[0]==arrIndxInPtr[it+1]-arrIndxInPtr[it])
- std::copy(srcArrPtr+srcArrIndexPtr[0],srcArrPtr+srcArrIndexPtr[1],arrInOutPtr+arrIndxInPtr[it]);
- else
- {
- std::ostringstream oss; oss << "MEDCouplingUMesh::SetPartOfIndexedArraysSameIdxSlice : On pos #" << i << " id (idsOfSelectBg[" << i << "]) is " << it << " arrIndxIn[id+1]-arrIndxIn[id]!=srcArrIndex[pos+1]-srcArrIndex[pos] !";
- throw INTERP_KERNEL::Exception(oss.str());
- }
- }
- else
- {
- std::ostringstream oss; oss << "MEDCouplingUMesh::SetPartOfIndexedArraysSameIdxSlice : On pos #" << i << " value is " << it << " not in [0," << nbOfTuples << ") !";
- throw INTERP_KERNEL::Exception(oss.str());
- }
- }
-}
/*!
* \b this is expected to be a mesh fully defined whose spaceDim==meshDim.
* The returned mesh contains as poly cells as number of contiguous zone (regarding connectivity).
* A spread contiguous zone is built using poly cells (polyhedra in 3D, polygons in 2D and polyline in 1D).
* The sum of measure field of returned mesh is equal to the sum of measure field of this.
- *
+ *
* \return a newly allocated mesh lying on the same coords than \b this with same meshdimension than \b this.
*/
MEDCouplingUMesh *MEDCouplingUMesh::buildSpreadZonesWithPoly() const
int spaceDim=getSpaceDimension();
if(mdim!=spaceDim)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::buildSpreadZonesWithPoly : meshdimension and spacedimension do not match !");
- std::vector<DataArrayInt *> partition=partitionBySpreadZone();
- std::vector< MCAuto<DataArrayInt> > partitionAuto; partitionAuto.reserve(partition.size());
- std::copy(partition.begin(),partition.end(),std::back_insert_iterator<std::vector< MCAuto<DataArrayInt> > >(partitionAuto));
+ std::vector<DataArrayIdType *> partition=partitionBySpreadZone();
+ std::vector< MCAuto<DataArrayIdType> > partitionAuto; partitionAuto.reserve(partition.size());
+ std::copy(partition.begin(),partition.end(),std::back_insert_iterator<std::vector< MCAuto<DataArrayIdType> > >(partitionAuto));
MCAuto<MEDCouplingUMesh> ret=MEDCouplingUMesh::New(getName(),mdim);
ret->setCoords(getCoords());
- ret->allocateCells((int)partition.size());
+ ret->allocateCells(ToIdType(partition.size()));
//
- for(std::vector<DataArrayInt *>::const_iterator it=partition.begin();it!=partition.end();it++)
+ for(std::vector<DataArrayIdType *>::const_iterator it=partition.begin();it!=partition.end();it++)
{
MCAuto<MEDCouplingUMesh> tmp=static_cast<MEDCouplingUMesh *>(buildPartOfMySelf((*it)->begin(),(*it)->end(),true));
- MCAuto<DataArrayInt> cell;
+ MCAuto<DataArrayIdType> cell;
switch(mdim)
{
case 2:
* This method only needs a well defined connectivity. Coordinates are not considered here.
* This method returns a vector of \b newly allocated arrays that the caller has to deal with.
*/
-std::vector<DataArrayInt *> MEDCouplingUMesh::partitionBySpreadZone() const
+std::vector<DataArrayIdType *> MEDCouplingUMesh::partitionBySpreadZone() const
{
- DataArrayInt *neigh=0,*neighI=0;
+ DataArrayIdType *neigh=0,*neighI=0;
computeNeighborsOfCells(neigh,neighI);
- MCAuto<DataArrayInt> neighAuto(neigh),neighIAuto(neighI);
+ MCAuto<DataArrayIdType> neighAuto(neigh),neighIAuto(neighI);
return PartitionBySpreadZone(neighAuto,neighIAuto);
}
-std::vector<DataArrayInt *> MEDCouplingUMesh::PartitionBySpreadZone(const DataArrayInt *arrIn, const DataArrayInt *arrIndxIn)
+std::vector<DataArrayIdType *> MEDCouplingUMesh::PartitionBySpreadZone(const DataArrayIdType *arrIn, const DataArrayIdType *arrIndxIn)
{
if(!arrIn || !arrIndxIn)
throw INTERP_KERNEL::Exception("PartitionBySpreadZone : null input pointers !");
arrIn->checkAllocated(); arrIndxIn->checkAllocated();
- int nbOfTuples(arrIndxIn->getNumberOfTuples());
+ mcIdType nbOfTuples(arrIndxIn->getNumberOfTuples());
if(arrIn->getNumberOfComponents()!=1 || arrIndxIn->getNumberOfComponents()!=1 || nbOfTuples<1)
throw INTERP_KERNEL::Exception("PartitionBySpreadZone : invalid arrays in input !");
- int nbOfCellsCur(nbOfTuples-1);
- std::vector<DataArrayInt *> ret;
+ mcIdType nbOfCellsCur(nbOfTuples-1);
+ std::vector<DataArrayIdType *> ret;
if(nbOfCellsCur<=0)
return ret;
std::vector<bool> fetchedCells(nbOfCellsCur,false);
- std::vector< MCAuto<DataArrayInt> > ret2;
- int seed=0;
+ std::vector< MCAuto<DataArrayIdType> > ret2;
+ mcIdType seed=0;
while(seed<nbOfCellsCur)
{
- int nbOfPeelPerformed=0;
+ mcIdType nbOfPeelPerformed=0;
ret2.push_back(ComputeSpreadZoneGraduallyFromSeedAlg(fetchedCells,&seed,&seed+1,arrIn,arrIndxIn,-1,nbOfPeelPerformed));
- seed=(int)std::distance(fetchedCells.begin(),std::find(fetchedCells.begin()+seed,fetchedCells.end(),false));
+ seed=ToIdType(std::distance(fetchedCells.begin(),std::find(fetchedCells.begin()+seed,fetchedCells.end(),false)));
}
- for(std::vector< MCAuto<DataArrayInt> >::iterator it=ret2.begin();it!=ret2.end();it++)
+ for(std::vector< MCAuto<DataArrayIdType> >::iterator it=ret2.begin();it!=ret2.end();it++)
ret.push_back((*it).retn());
return ret;
}
/*!
* This method returns given a distribution of cell type (returned for example by MEDCouplingUMesh::getDistributionOfTypes method and customized after) a
- * newly allocated DataArrayInt instance with 2 components ready to be interpreted as input of DataArrayInt::findRangeIdForEachTuple method.
+ * newly allocated DataArrayIdType instance with 2 components ready to be interpreted as input of DataArrayIdType::findRangeIdForEachTuple method.
*
* \param [in] code a code with the same format than those returned by MEDCouplingUMesh::getDistributionOfTypes except for the code[3*k+2] that should contain start id of chunck.
- * \return a newly allocated DataArrayInt to be managed by the caller.
+ * \return a newly allocated DataArrayIdType to be managed by the caller.
* \throw In case of \a code has not the right format (typically of size 3*n)
*/
-DataArrayInt *MEDCouplingUMesh::ComputeRangesFromTypeDistribution(const std::vector<int>& code)
+DataArrayIdType *MEDCouplingUMesh::ComputeRangesFromTypeDistribution(const std::vector<mcIdType>& code)
{
- MCAuto<DataArrayInt> ret=DataArrayInt::New();
+ MCAuto<DataArrayIdType> ret=DataArrayIdType::New();
std::size_t nb=code.size()/3;
if(code.size()%3!=0)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::ComputeRangesFromTypeDistribution : invalid input code !");
- ret->alloc((int)nb,2);
- int *retPtr=ret->getPointer();
+ ret->alloc(nb,2);
+ mcIdType *retPtr=ret->getPointer();
for(std::size_t i=0;i<nb;i++,retPtr+=2)
{
retPtr[0]=code[3*i+2];
* This method will split **all** 3D cells in \a this into INTERP_KERNEL::NORM_TETRA4 cells and put them in the returned mesh.
* It leads to an increase to number of cells.
* This method contrary to MEDCouplingUMesh::simplexize can append coordinates in \a this to perform its work.
- * The \a nbOfAdditionalPoints returned value informs about it. If > 0, the coordinates array in returned mesh will have \a nbOfAdditionalPoints
+ * The \a nbOfAdditionalPoints returned value informs about it. If > 0, the coordinates array in returned mesh will have \a nbOfAdditionalPoints
* more tuples (nodes) than in \a this. Anyway, all the nodes in \a this (with the same order) will be in the returned mesh.
*
* \param [in] policy - the policy of splitting that must be in (PLANAR_FACE_5, PLANAR_FACE_6, GENERAL_24, GENERAL_48). The policy will be used only for INTERP_KERNEL::NORM_HEXA8 cells.
* For all other cells, the splitting policy will be ignored. See INTERP_KERNEL::SplittingPolicy for the images.
- * \param [out] nbOfAdditionalPoints - number of nodes added to \c this->_coords. If > 0 a new coordinates object will be constructed result of the aggregation of the old one and the new points added.
- * \param [out] n2oCells - A new instance of DataArrayInt holding, for each new cell,
+ * \param [out] nbOfAdditionalPoints - number of nodes added to \c this->_coords. If > 0 a new coordinates object will be constructed result of the aggregation of the old one and the new points added.
+ * \param [out] n2oCells - A new instance of DataArrayIdType holding, for each new cell,
* an id of old cell producing it. The caller is to delete this array using
* decrRef() as it is no more needed.
* \return MEDCoupling1SGTUMesh * - the mesh containing only INTERP_KERNEL::NORM_TETRA4 cells.
*
* \warning This method operates on each cells in this independently ! So it can leads to non conform mesh in returned value ! If you expect to have a conform mesh in output
* the policy PLANAR_FACE_6 should be used on a mesh sorted with MEDCoupling1SGTUMesh::sortHexa8EachOther.
- *
+ *
* \throw If \a this is not a 3D mesh (spaceDim==3 and meshDim==3).
* \throw If \a this is not fully constituted with linear 3D cells.
* \sa MEDCouplingUMesh::simplexize, MEDCoupling1SGTUMesh::sortHexa8EachOther
*/
-MEDCoupling1SGTUMesh *MEDCouplingUMesh::tetrahedrize(int policy, DataArrayInt *& n2oCells, int& nbOfAdditionalPoints) const
+MEDCoupling1SGTUMesh *MEDCouplingUMesh::tetrahedrize(int policy, DataArrayIdType *& n2oCells, mcIdType& nbOfAdditionalPoints) const
{
INTERP_KERNEL::SplittingPolicy pol((INTERP_KERNEL::SplittingPolicy)policy);
checkConnectivityFullyDefined();
if(getMeshDimension()!=3 || getSpaceDimension()!=3)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::tetrahedrize : only available for mesh with meshdim == 3 and spacedim == 3 !");
- int nbOfCells(getNumberOfCells()),nbNodes(getNumberOfNodes());
+ mcIdType nbOfCells=getNumberOfCells();
+ mcIdType nbNodes(getNumberOfNodes());
MCAuto<MEDCoupling1SGTUMesh> ret0(MEDCoupling1SGTUMesh::New(getName(),INTERP_KERNEL::NORM_TETRA4));
- MCAuto<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(nbOfCells,1);
- int *retPt(ret->getPointer());
- MCAuto<DataArrayInt> newConn(DataArrayInt::New()); newConn->alloc(0,1);
+ MCAuto<DataArrayIdType> ret(DataArrayIdType::New()); ret->alloc(nbOfCells,1);
+ mcIdType *retPt(ret->getPointer());
+ MCAuto<DataArrayIdType> newConn(DataArrayIdType::New()); newConn->alloc(0,1);
MCAuto<DataArrayDouble> addPts(DataArrayDouble::New()); addPts->alloc(0,1);
- const int *oldc(_nodal_connec->begin());
- const int *oldci(_nodal_connec_index->begin());
+ const mcIdType *oldc(_nodal_connec->begin());
+ const mcIdType *oldci(_nodal_connec_index->begin());
const double *coords(_coords->begin());
- for(int i=0;i<nbOfCells;i++,oldci++,retPt++)
+ for(mcIdType i=0;i<nbOfCells;i++,oldci++,retPt++)
{
- std::vector<int> a; std::vector<double> b;
+ std::vector<mcIdType> a; std::vector<double> b;
INTERP_KERNEL::SplitIntoTetras(pol,(INTERP_KERNEL::NormalizedCellType)oldc[oldci[0]],oldc+oldci[0]+1,oldc+oldci[1],coords,a,b);
- std::size_t nbOfTet(a.size()/4); *retPt=(int)nbOfTet;
- const int *aa(&a[0]);
+ std::size_t nbOfTet(a.size()/4); *retPt=ToIdType(nbOfTet);
+ const mcIdType *aa(&a[0]);
if(!b.empty())
{
- for(std::vector<int>::iterator it=a.begin();it!=a.end();it++)
+ for(std::vector<mcIdType>::iterator it=a.begin();it!=a.end();it++)
if(*it<0)
*it=(-(*(it))-1+nbNodes);
addPts->insertAtTheEnd(b.begin(),b.end());
- nbNodes+=(int)b.size()/3;
+ nbNodes+=ToIdType(b.size()/3);
}
for(std::size_t j=0;j<nbOfTet;j++,aa+=4)
newConn->insertAtTheEnd(aa,aa+4);
delete _cell;
}
-MEDCouplingUMeshCellIterator::MEDCouplingUMeshCellIterator(MEDCouplingUMesh *mesh, MEDCouplingUMeshCell *itc, int bg, int end):_mesh(mesh),_cell(itc),
+MEDCouplingUMeshCellIterator::MEDCouplingUMeshCellIterator(MEDCouplingUMesh *mesh, MEDCouplingUMeshCell *itc, mcIdType bg, mcIdType end):_mesh(mesh),_cell(itc),
_own_cell(false),_cell_id(bg-1),
_nb_cell(end)
{
_mesh->decrRef();
}
-MEDCouplingUMeshCellEntry::MEDCouplingUMeshCellEntry(MEDCouplingUMesh *mesh, INTERP_KERNEL::NormalizedCellType type, MEDCouplingUMeshCell *itc, int bg, int end):_mesh(mesh),_type(type),
+MEDCouplingUMeshCellEntry::MEDCouplingUMeshCellEntry(MEDCouplingUMesh *mesh, INTERP_KERNEL::NormalizedCellType type, MEDCouplingUMeshCell *itc, mcIdType bg, mcIdType end):_mesh(mesh),_type(type),
_itc(itc),
_bg(bg),_end(end)
{
return _type;
}
-int MEDCouplingUMeshCellEntry::getNumberOfElems() const
+mcIdType MEDCouplingUMeshCellEntry::getNumberOfElems() const
{
return _end-_bg;
}
MEDCouplingUMeshCellEntry *MEDCouplingUMeshCellByTypeIterator::nextt()
{
- const int *c=_mesh->getNodalConnectivity()->begin();
- const int *ci=_mesh->getNodalConnectivityIndex()->begin();
+ const mcIdType *c=_mesh->getNodalConnectivity()->begin();
+ const mcIdType *ci=_mesh->getNodalConnectivityIndex()->begin();
if(_cell_id<_nb_cell)
{
INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)c[ci[_cell_id]];
- int nbOfElems=(int)std::distance(ci+_cell_id,std::find_if(ci+_cell_id,ci+_nb_cell,MEDCouplingImpl::ConnReader(c,type)));
- int startId=_cell_id;
+ mcIdType nbOfElems=ToIdType(std::distance(ci+_cell_id,std::find_if(ci+_cell_id,ci+_nb_cell,MEDCouplingImpl::ConnReader(c,type))));
+ mcIdType startId=_cell_id;
_cell_id+=nbOfElems;
return new MEDCouplingUMeshCellEntry(_mesh,type,_cell,startId,_cell_id);
}
{
std::ostringstream oss; oss << "Cell Type " << INTERP_KERNEL::CellModel::GetCellModel((INTERP_KERNEL::NormalizedCellType)_conn[0]).getRepr();
oss << " : ";
- std::copy(_conn+1,_conn+_conn_lgth,std::ostream_iterator<int>(oss," "));
+ std::copy(_conn+1,_conn+_conn_lgth,std::ostream_iterator<mcIdType>(oss," "));
return oss.str();
}
else
return INTERP_KERNEL::NORM_ERROR;
}
-const int *MEDCouplingUMeshCell::getAllConn(int& lgth) const
+const mcIdType *MEDCouplingUMeshCell::getAllConn(mcIdType& lgth) const
{
lgth=_conn_lgth;
if(_conn_lgth!=NOTICABLE_FIRST_VAL)