-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D
+// Copyright (C) 2007-2024 CEA, EDF
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
#include <sstream>
#include <fstream>
#include <numeric>
+#include <memory>
#include <cstring>
#include <limits>
#include <list>
double MEDCouplingUMesh::EPS_FOR_POLYH_ORIENTATION=1.e-14;
/// @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};
/// @endcond
MEDCouplingUMesh *MEDCouplingUMesh::New()
{
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);
/*!
* Checks if \a this mesh is well defined. If no exception is thrown by this method,
- * then \a this mesh is most probably is writable, exchangeable and available for all
+ * then \a this mesh is informatically clean, most probably is writable, exchangeable and available for all
* algorithms. <br> In addition to the checks performed by checkConsistencyLight(), this
- * method thoroughly checks the nodal connectivity.
+ * method thoroughly checks the nodal connectivity. For more geometrical checking
+ * checkGeomConsistency method is better than this.
+ *
+ * \sa MEDCouplingUMesh::checkGeomConsistency
+ *
* \param [in] eps - a not used parameter.
* \throw If the mesh dimension is not set.
* \throw If the coordinates array is not set (if mesh dimension != -1 ).
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)
}
}
+/*!
+ * This method adds some geometrical checks in addition to the informatical check of checkConsistency method.
+ * This method in particular checks that a same node is not repeated several times in a cell.
+ *
+ * \throw If there is a presence a multiple same node ID in nodal connectivity of cell.
+ */
+void MEDCouplingUMesh::checkGeomConsistency(double eps) const
+{
+ this->checkConsistency(eps);
+ auto nbOfCells(getNumberOfCells());
+ const mcIdType *ptr(_nodal_connec->begin()),*ptrI(_nodal_connec_index->begin());
+ for(auto icell = 0 ; icell < nbOfCells ; ++icell)
+ {
+ std::set<mcIdType> s(ptr+ptrI[icell]+1,ptr+ptrI[icell+1]);
+ if(ToIdType(s.size())==ptrI[icell+1]-ptrI[icell]-1)
+ continue;
+ std::ostringstream oss; oss << "MEDCouplingUMesh::checkGeomConsistency : for cell #" << icell << " presence of multiple same nodeID !";
+ throw INTERP_KERNEL::Exception(oss.str());
+ }
+}
+
+
/*!
* Sets dimension of \a this mesh. The mesh dimension in general depends on types of
* elements contained in the mesh. For more info on the mesh dimension see
* \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();
* \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);
{
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;
* \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::bind(std::equal_to<mcIdType>(),std::placeholders::_1,-1))=eltId;
}
}
* \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 is a generalization of buildDescendingConnectivity method. This method return mesh containing subcells of this at level specified by \a targetDeltaLevel
+ * and return descending and reverse descending correspondances to this.
+ *
+ * \param [in] targetDeltaLevel target delta level compared to \a this mesh dimension. This parameter is expected to be lower than zero.
+ *
+ * \throw If targetDeltaLevel is greater or equal to zero
+ * \throw If targetDeltaLevel is lower than -meshDim
+ * \sa MEDCouplingUMesh::buildDescendingConnectivity, MEDCouplingUMesh::explode3DMeshTo1D
+ */
+MCAuto<MEDCouplingUMesh> MEDCouplingUMesh::explodeMeshTo(int targetDeltaLevel, MCAuto<DataArrayIdType>& desc, MCAuto<DataArrayIdType>& descIndx, MCAuto<DataArrayIdType>& revDesc, MCAuto<DataArrayIdType>& revDescIndx) const
+{
+ this->checkConsistencyLight();
+ if( targetDeltaLevel >= 0 )
+ THROW_IK_EXCEPTION("Input parameter targetDeltaLevel is expected to be lower than zero !");
+ if( targetDeltaLevel == -1 )
+ {
+ desc = DataArrayIdType::New(); descIndx = DataArrayIdType::New(); revDesc = DataArrayIdType::New(); revDescIndx = DataArrayIdType::New();
+ MCAuto<MEDCouplingUMesh> ret( this->buildDescendingConnectivity(desc,descIndx,revDesc,revDescIndx) );
+ return ret;
+ }
+ if( targetDeltaLevel == -2 && this->getMeshDimension() == 3 )
+ {
+ desc = DataArrayIdType::New(); descIndx = DataArrayIdType::New(); revDesc = DataArrayIdType::New(); revDescIndx = DataArrayIdType::New();
+ MCAuto<MEDCouplingUMesh> ret( this->explode3DMeshTo1D(desc,descIndx,revDesc,revDescIndx) );
+ return ret;
+ }
+ if( targetDeltaLevel == -this->getMeshDimension() )
+ {
+ MCAuto<MEDCouplingUMesh> ret = MEDCouplingUMesh::Build0DMeshFromCoords( const_cast<DataArrayDouble *>( this->getCoords() ) );
+ MEDCouplingUMesh::DeleteCellTypeInIndexedArray(getNodalConnectivity(),getNodalConnectivityIndex(),desc,descIndx);
+ revDesc = DataArrayIdType::New(); revDescIndx = DataArrayIdType::New();
+ this->getReverseNodalConnectivity(revDesc,revDescIndx);
+ return ret;
+ }
+ THROW_IK_EXCEPTION("Not valid input targetDeltaLevel regarding mesh dimension");
+}
+
/*!
* \a this has to have a mesh dimension equal to 3. If it is not the case an INTERP_KERNEL::Exception will be thrown.
* This behaves exactly as MEDCouplingUMesh::buildDescendingConnectivity does except that this method compute directly the transition from mesh dimension 3 to sub edges (dimension 1)
* 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())
* \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);
}
* \b WARNING this method do the assumption that connectivity lies on the coordinates set.
* For speed reasons no check of this will be done. This method calls
* MEDCouplingUMesh::buildDescendingConnectivity to compute the result.
- * This method lists cell by cell in \b this which are its neighbors. To compute the result
+ * This method lists for every cell in \b this its neighbor \b cells. To compute the result
* only connectivities are considered.
- * The neighbor cells of cell having id 'cellId' are neighbors[neighborsIndx[cellId]:neighborsIndx[cellId+1]].
+ * The neighbor cells of a given cell having id 'cellId' are neighbors[neighborsIndx[cellId]:neighborsIndx[cellId+1]].
* The format of return is hence \ref numbering-indirect.
*
* \param [out] neighbors is an array storing all the neighbors of all cells in \b this. This array is newly
* \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
+/**
+ * Given a set of identifiers indexed by the node IDs of the mesh (and given in the (\ref numbering-indirect format) ,
+ * re-arrange the data to produce a set indexed by cell IDs. The mapping between a node ID and a cell ID is done using the connectivity
+ * of the mesh (e.g. a triangular element will receive the information from its three vertices).
+ * Doublons are eliminated. If present in the inital dataset, the ID of the cell itself is also remooved.
+ *
+ * \param [in] nodeNeigh a set of identifiers (mcIdType) stored by node index (\ref numbering-indirect format)
+ * \param [in] nodeNeighI a set of identifiers (mcIdType) stored by node index (\ref numbering-indirect format)
+ * \param [out] cellNeigh This array is newly allocated and should be dealt by the caller. It contains the initial identifiers
+ * provided in the input parameters but stored now by cell index (See 2nd output parameter and \ref numbering-indirect).
+ * \param [out] cellNeighI 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).
+ *
+ * \raise if the number of tuples in nodeNeighI is not equal to the number of nodes in the mesh.
+ */
+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++)
- {
- std::set<int> s;
- for(const int *it=c+ci[i]+1;it!=c+ci[i+1];it++)
- if(*it>=0)
+ 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<mcIdType> s;
+ for(const mcIdType *it=c+ci[i]+1;it!=c+ci[i+1];it++)
+ if(*it>=0) // avoid -1 in polygons or polyedrons
s.insert(ne+nei[*it],ne+nei[*it+1]);
s.erase(i);
cellNeigh->insertAtTheEnd(s.begin(),s.end());
* 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)
{
* \b WARNING this method do the assumption that connectivity lies on the coordinates set.
* For speed reasons no check of this will be done. This method calls
* MEDCouplingUMesh::buildDescendingConnectivity to compute the result.
- * This method lists node by node in \b this which are its neighbors. To compute the result
+ * This method lists for every node in \b this its neighbor \b nodes. To compute the result
* only connectivities are considered.
* The neighbor nodes of node having id 'nodeId' are neighbors[neighborsIndx[cellId]:neighborsIndx[cellId+1]].
*
*
* \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();
*
* \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=0;
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;
}
- case 1:
+ /* case 1: // Not supported yet
{
newType=(lgthOfCurCell==3)?INTERP_KERNEL::NORM_SEG2:INTERP_KERNEL::NORM_POLYL;
break;
}
+ */
}
ret=ret || (newType!=type);
conn[newPos]=newType;
* 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.
*
+ * \b WARNING: this method will not modify edges connectivity! Take a look at colinearizeEdges for that.
+ *
* \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.
*/
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;
setConnectivity(connNew,connINew,false);
}
+/*!
+ * 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 simplify edges of polyhedron cells so that consecutive colinear segments (with intermediate points
+ * not used by any other cell) are merged together.
+ *
+ * \param [in] eps is a relative precision that allows to establish if two consecutive 3D segments are colinear or not.
+ *
+ * \sa simplifyPolyhedra
+ */
+void MEDCouplingUMesh::colinearizeEdges(double eps)
+{
+ //
+ // Thanks to Antoine Gerschenfeld (CEA) for contributing this method!
+ //
+ using DAI = MCAuto<DataArrayIdType>;
+ checkFullyDefined();
+ if(getMeshDimension()!=3 || getSpaceDimension()!=3)
+ throw INTERP_KERNEL::Exception("MEDCouplingUMesh::colinearizeEdges() : works with meshdim=3 and spaceDim=3!");
+ double seps = sqrt(1-eps);
+ // Computing connectivities and correspondances : elements -> segments -> points
+ DAI E_Fi(DataArrayIdType::New()), E_F(DataArrayIdType::New()), F_Ei(DataArrayIdType::New()), F_E(DataArrayIdType::New()),
+ F_Si(DataArrayIdType::New()), F_S(DataArrayIdType::New()), S_Fi(DataArrayIdType::New()), S_F(DataArrayIdType::New()),
+ S_Pi(DataArrayIdType::New()), S_P(DataArrayIdType::New()), P_Si(DataArrayIdType::New()), P_S(DataArrayIdType::New());
+ MCAuto<MEDCouplingUMesh> m_f(buildDescendingConnectivity(E_F, E_Fi, F_E, F_Ei)),
+ m_s(m_f->buildDescendingConnectivity(F_S, F_Si, S_F, S_Fi)),
+ m_p(m_s->buildDescendingConnectivity(S_P, S_Pi, P_S, P_Si)); // E: elem, F: faces, S: segments (edges), P: points (vertices)
+ const mcIdType *S_Pp(S_P->begin()), *S_Pip(S_Pi->begin()), *P_Sp(P_S->begin()), *P_Sip(P_Si->begin());
+ std::set<mcIdType> pt_rem;
+ const mcIdType *m_pi = m_p->getNodalConnectivityIndex()->begin(),
+ *m_pc = m_p->getNodalConnectivity()->begin();
+ double (*coord)[3] = (double (*)[3]) getCoords()->begin();
+ // Find all points only connected to exaclty 2 segments - they are the candidates for elimination
+ // Note that in 3D this can only happen for polyhedrons (when this happens at all)
+ DAI dsi = P_Si->deltaShiftIndex();
+ DAI cand = dsi->findIdsEqual(2);
+ for (const mcIdType& i: *cand) // i is a point to be potentially eliminated, shared by 2 segs only
+ {
+ double n2[2] = {0., 0.}, scal = 0.; // n2 is a squared norm, scal is a scalar product
+ mcIdType p[2][2]; // p[j][k] is the ID (in the coord array) of the k-th point of the j-th segment
+ for (mcIdType j = 0; j < 2; j++)
+ for (mcIdType k = 0; k < 2; k++)
+ {
+ mcIdType off1 = P_Sip[i] + j; // offset to get ID of the j-th seg (around the i-th point) in the point->seg correspondance
+ mcIdType pt_id = P_Sp[off1] + k; // ID of the k-th point of the j-th seg in the point->seg correspondance
+ mcIdType pt_id2 = S_Pp[S_Pip[pt_id]]; // ID of the point in the point mesh
+ p[j][k] = m_pc[m_pi[pt_id2] + 1]; // Absolute ID, as read from the connectvity (+1 to skip type: NORM_POINT1)
+ // Just for fun, as initially written by Antoine :-)
+ // p[j][k] = m_pc[m_pi[S_P->getIJ(S_Pi->getIJ(P_S->getIJ(P_Si->getIJ(i, 0) + j, 0), 0) + k, 0)] + 1];
+ }
+ // Geometric test on scalar product
+ for (int d = 0; d < 3; d++) // dimension
+ {
+ for (int j = 0; j < 2; j++)
+ n2[j] += std::pow(coord[p[j][1]][d] - coord[p[j][0]][d], 2);
+ scal += (coord[p[1][1]][d] - coord[p[1][0]][d]) * (coord[p[0][1]][d] - coord[p[0][0]][d]);
+ }
+ if (scal * scal > seps * n2[0] * n2[1]) // seps is a sqrt for homogeneity
+ pt_rem.insert(m_pc[m_pi[i] + 1]); // point should be removed
+ }
+ // Clean connectivity by filtering points to be removed:
+ DataArrayIdType *old_index = getNodalConnectivityIndex(), *old_conn = getNodalConnectivity();
+ DAI new_index(DataArrayIdType::New()), new_conn(DataArrayIdType::New());
+ const mcIdType *old_index_p(old_index->begin()), *old_conn_p(old_conn->begin());
+ for (mcIdType i = 0; i < getNumberOfCells(); i++)
+ {
+ new_index->pushBackSilent(new_conn->getNbOfElems());
+ for (mcIdType j = old_index_p[i]; j < old_index_p[i + 1]; j++)
+ {
+ // Keep point if it is not to be removed, or if is first in connectivity (TODO this last check could be removed?)
+ if (std::find(pt_rem.begin(), pt_rem.end(), old_conn_p[j]) == pt_rem.end() || j == old_index_p[i])
+ new_conn->pushBackSilent(old_conn_p[j]);
+ }
+ }
+ new_index->pushBackSilent(new_conn->getNbOfElems());
+ setConnectivity(new_conn, new_index);
+}
+
/*!
* 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.
+ * the format of the returned DataArrayIdType instance.
*
- * \return a newly allocated DataArrayInt sorted ascendingly of fetched node ids.
+ * \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
* by excluding the unused nodes, for which the array holds -1. The result array is
* 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.
* \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();
}
* \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();
*
* \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
+ * \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.
* \throw If the coordinates array is not set.
* \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 0;
}
-
- return work!=tmp+sz1?1:0;
}
else
{//case of SEG2 and SEG3
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;
/*!
- * This method find cells that are equal (regarding \a compType) in \a this. The comparison is specified
- * by \a compType.
- * This method keeps the coordiantes of \a this. This method is time consuming.
+ * This method find cells that are equal (regarding \a compType) in \a this. The comparison is specified by \a compType (see zipConnectivityTraducer).
+ * This method keeps the coordinates of \a this. The comparison starts at rank \a startCellId cell id (included).
+ * If \a startCellId is equal to 0 algorithm starts at cell #0 and for each cell candidates being searched have cell id higher than current cellId.
+ * If \a startCellId is greater than 0 algorithm starts at cell #startCellId but for each cell all candidates are considered.
+ * This method is time consuming.
*
* \param [in] compType input specifying the technique used to compare cells each other.
* - 0 : exactly. A cell is detected to be the same if and only if the connectivity is exactly the same without permutation and types same too. This is the strongest policy.
* \param [in] startCellId specifies the cellId starting from which the equality computation will be carried out. By default it is 0, which it means that all cells in \a this will be scanned.
* \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=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::bind(std::not_equal_to<mcIdType>(),std::placeholders::_1,-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::bind(std::not_equal_to<mcIdType>(),std::placeholders::_1,-1));
+ // v2 contains the result of successive intersections using rev nodal on on each node of cell #i
+ 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));
}
+ // v2 contains now candidates. Problem candidates are sorted using id rank.
if(v2.size()>1)
{
+ if(v2[0]!=i)
+ {
+ auto it(std::find(v2.begin(),v2.end(),i));
+ std::swap(*v2.begin(),*it);
+ }
if(AreCellsEqualInPool(v2,compType,connPtr,connIPtr,commonCells))
{
- int pos=commonCellsI->back();
- commonCellsI->pushBackSilent(commonCells->getNumberOfTuples());
- for(const int *it=commonCells->begin()+pos;it!=commonCells->end();it++)
+ mcIdType newPos(commonCells->getNumberOfTuples());
+ mcIdType pos(commonCellsI->back());
+ std::sort(commonCells->getPointerSilent()+pos,commonCells->getPointerSilent()+newPos);
+ commonCellsI->pushBackSilent(newPos);
+ for(const mcIdType *it=commonCells->begin()+pos;it!=commonCells->end();it++)
isFetched[*it]=true;
}
}
* \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);
- arr=o2n->subArray(nbOfCells);
- arr->setName(other->getName());
- int tmp;
+ //
if(other->getNumberOfCells()==0)
+ {
+ MCAuto<DataArrayIdType> dftRet(DataArrayIdType::New()); dftRet->alloc(0,1); arr=dftRet.retn(); arr->setName(other->getName());
return true;
- return arr->getMaxValue(tmp)<nbOfCells;
+ }
+ DataArrayIdType *commonCells(nullptr),*commonCellsI(nullptr);
+ mesh->findCommonCells(compType,nbOfCells,commonCells,commonCellsI);
+ MCAuto<DataArrayIdType> commonCellsTmp(commonCells),commonCellsITmp(commonCellsI);
+ mcIdType newNbOfCells=-1;
+ MCAuto<DataArrayIdType> o2n = DataArrayIdType::ConvertIndexArrayToO2N(ToIdType(mesh->getNumberOfCells()),commonCells->begin(),commonCellsI->begin(),commonCellsI->end(),newNbOfCells);
+ MCAuto<DataArrayIdType> p0(o2n->selectByTupleIdSafeSlice(0,nbOfCells,1));
+ mcIdType maxPart(p0->getMaxValueInArray());
+ bool ret(maxPart==newNbOfCells-1);
+ MCAuto<DataArrayIdType> p1(p0->invertArrayO2N2N2O(newNbOfCells));
+ // fill p1 array in case of presence of cells in other not in this
+ mcIdType *pt(p1->getPointer());
+ for(mcIdType i = maxPart ; i < newNbOfCells-1 ; ++i )
+ pt[i+1] = i+1;
+ //
+ MCAuto<DataArrayIdType> p2(o2n->subArray(nbOfCells));
+ p2->transformWithIndArr(p1->begin(),p1->end()); p2->setName(other->getName());
+ arr = p2.retn();
+ return ret;
}
/*!
* \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);
}
* 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 start starting ID
+ * \param end end ID (excluded)
+ * \param step step size
* \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)
* \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);
}
}
* \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));
*/
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.
*/
-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> ret2(DataArrayIdType::New());
+
+ if (getNumberOfCells() == 0)
+ {
+ ret2->alloc(0,1);
+ return ret2.retn();
+ }
+
+ MCAuto<DataArrayIdType> desc(DataArrayIdType::New()), descIndx(DataArrayIdType::New()), revDesc(DataArrayIdType::New()), 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();
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)
*ret2Ptr++=sz;
ret2->setName("BoundaryCells");
- return ret2;
+ return ret2.retn();
}
/*!
* \throw if \b otherDimM1OnSameCoords is not part of constituent of \b this, or if coordinate pointer of \b this and \b otherDimM1OnSameCoords
* are not same, or if this->getMeshDimension()-1!=otherDimM1OnSameCoords.getMeshDimension()
*
- * \param [in] otherDimM1OnSameCoords
+ * \param [in] otherDimM1OnSameCoords other mesh
* \param [out] cellIdsRk0 a newly allocated array containing the cell ids of s0 (which are cell ids of \b this) in the above algorithm.
* \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();
*/
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();
/*!
* This method expects that \b this and \b otherDimM1OnSameCoords share the same coordinates array.
* otherDimM1OnSameCoords->getMeshDimension() is expected to be equal to this->getMeshDimension()-1.
- * This method searches for nodes needed to be duplicated. These nodes are nodes fetched by \b otherDimM1OnSameCoords which are not part of the boundary of \b otherDimM1OnSameCoords.
- * If a node is in the boundary of \b this \b and in the boundary of \b otherDimM1OnSameCoords this node is considered as needed to be duplicated.
+ * This method searches for nodes needed to be duplicated. Those are the nodes fetched by \b otherDimM1OnSameCoords which are not part of the boundary of \b otherDimM1OnSameCoords.
+ * If a node is in the boundary of \b this \b and in the boundary of \b otherDimM1OnSameCoords, it will be duplicated.
* When the set of node ids \b nodeIdsToDuplicate is computed, cell ids in \b this is searched so that their connectivity includes at least 1 node in \b nodeIdsToDuplicate.
*
- * \param [in] otherDimM1OnSameCoords a mesh lying on the same coords than \b this and with a mesh dimension equal to those of \b this minus 1. WARNING this input
+ * \param [in] crackingMesh a mesh lying on the same coords than \b this and with a mesh dimension equal to those of \b this minus 1. WARNING this input
* 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.
+ * \return node ids which need to be duplicated following the algorithm explained above.
*
- * \warning This method modifies param \b otherDimM1OnSameCoords (for speed reasons).
*/
-void MEDCouplingUMesh::findNodesToDuplicate(const MEDCouplingUMesh& otherDimM1OnSameCoords, DataArrayInt *& nodeIdsToDuplicate,
- DataArrayInt *& cellIdsNeededToBeRenum, DataArrayInt *& cellIdsNotModified) const
+DataArrayIdType* MEDCouplingUMesh::findNodesToDuplicate(const MEDCouplingUMesh& crackingMesh) const
{
- typedef MCAuto<DataArrayInt> DAInt;
- typedef MCAuto<MEDCouplingUMesh> MCUMesh;
+ // DEBUG NOTE: in case of issue with the algorithm in this method, see Python script in resources/dev
+ // which mimicks the C++
+ using DAInt = MCAuto<DataArrayIdType>;
+ using MCUMesh = MCAuto<MEDCouplingUMesh>;
checkFullyDefined();
- otherDimM1OnSameCoords.checkFullyDefined();
- if(getCoords()!=otherDimM1OnSameCoords.getCoords())
+ crackingMesh.checkFullyDefined();
+ if(getCoords()!=crackingMesh.getCoords())
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::findNodesToDuplicate : meshes do not share the same coords array !");
- if(otherDimM1OnSameCoords.getMeshDimension()!=getMeshDimension()-1)
+ if(crackingMesh.getMeshDimension()!=getMeshDimension()-1)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::findNodesToDuplicate : the mesh given in other parameter must have this->getMeshDimension()-1 !");
+ // Clean the M1 group (cracking mesh): the M1 cells which are part of M0 boundary are irrelevant (we can't create a crack on the boundary of M0!)
+ MCUMesh m0skin = computeSkin();
+ DataArrayIdType *idsToKeepP;
+ m0skin->areCellsIncludedIn(&crackingMesh,2, idsToKeepP);
+ DAInt idsToKeep(idsToKeepP);
+ DAInt ids2 = idsToKeep->findIdsNotInRange(0, m0skin->getNumberOfCells()); // discard cells on the skin of M0
+ MCUMesh otherDimM1OnSameCoords =static_cast<MEDCouplingUMesh *>(crackingMesh.buildPartOfMySelf(ids2->begin(), ids2->end(), true));
+
+ if (!otherDimM1OnSameCoords->getNumberOfCells())
+ return MCAuto<DataArrayIdType>(DataArrayIdType::New()).retn();
+
// Checking star-shaped M1 group:
- DAInt dt0=DataArrayInt::New(),dit0=DataArrayInt::New(),rdt0=DataArrayInt::New(),rdit0=DataArrayInt::New();
- MCUMesh meshM2 = otherDimM1OnSameCoords.buildDescendingConnectivity(dt0, dit0, rdt0, rdit0);
+ DAInt dt0=DataArrayIdType::New(),dit0=DataArrayIdType::New(),rdt0=DataArrayIdType::New(),rdit0=DataArrayIdType::New();
+ MCUMesh meshM2 = otherDimM1OnSameCoords->buildDescendingConnectivity(dt0, dit0, rdt0, rdit0); // 2D: a mesh of points, 3D: a mesh of segs
DAInt dsi = rdit0->deltaShiftIndex();
- DAInt idsTmp0 = dsi->findIdsNotInRange(-1, 3);
+ DAInt idsTmp0 = dsi->findIdsNotInRange(-1, 3); // for 2D: if a point is connected to more than 2 segs. For 3D: if a seg is connected to more than two faces.
if(idsTmp0->getNumberOfTuples())
throw INTERP_KERNEL::Exception("MEDFileUMesh::buildInnerBoundaryAlongM1Group: group is too complex: some points (or edges) have more than two connected segments (or faces)!");
dt0=0; dit0=0; rdt0=0; rdit0=0; idsTmp0=0;
- // Get extreme nodes from the group (they won't be duplicated), ie nodes belonging to boundary cells of M1
+ // Get extreme nodes from the group (they won't be duplicated except if they also lie on bound of M0 -- see below),
+ // ie nodes belonging to the boundary "cells" (might be points) of M1
DAInt xtremIdsM2 = dsi->findIdsEqual(1); dsi = 0;
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();
- 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
- MCUMesh m0descSkin = static_cast<MEDCouplingUMesh *>(m0desc->buildPartOfMySelf(boundSegs->begin(),boundSegs->end(), true));
- DAInt fNodes = m0descSkin->computeFetchedNodeIds();
- // In 3D, some points on the boundary of M0 still need duplication:
+ // Remove from the list points on the boundary of the M0 mesh (those need duplication!).
+ // In 3D, some points on the boundary of M0 will NOT be duplicated (where as in 2D, points on the boundary of M0 are always duplicated)
+ // Think of a partial (plane) crack in a cube: the points at the tip of the crack and not located inside the volume of the cube are not duplicated
+ // although they are technically on the skin of the cube.
+ DAInt fNodes = m0skin->computeFetchedNodeIds();
DAInt notDup = 0;
if (getMeshDimension() == 3)
{
- DAInt dnu1=DataArrayInt::New(), dnu2=DataArrayInt::New(), dnu3=DataArrayInt::New(), dnu4=DataArrayInt::New();
- MCUMesh m0descSkinDesc = m0descSkin->buildDescendingConnectivity(dnu1, dnu2, dnu3, dnu4);
+ DAInt dnu1=DataArrayIdType::New(), dnu2=DataArrayIdType::New(), dnu3=DataArrayIdType::New(), dnu4=DataArrayIdType::New();
+ MCUMesh m0skinDesc = m0skin->buildDescendingConnectivity(dnu1, dnu2, dnu3, dnu4); // all segments of the skin of the 3D (M0) mesh
dnu1=0;dnu2=0;dnu3=0;dnu4=0;
- DataArrayInt * corresp=0;
- meshM2->areCellsIncludedIn(m0descSkinDesc,2,corresp);
+ DataArrayIdType * corresp=0;
+ meshM2->areCellsIncludedIn(m0skinDesc,2,corresp);
+ // validIds is the list of segments which are on both the skin of *this*, and in the segments of the M1 group
+ // In the cube example above, this is a U-shaped polyline.
DAInt validIds = corresp->findIdsInRange(0, meshM2->getNumberOfCells());
corresp->decrRef();
if (validIds->getNumberOfTuples())
{
- MCUMesh m1IntersecSkin = static_cast<MEDCouplingUMesh *>(m0descSkinDesc->buildPartOfMySelf(validIds->begin(), validIds->end(), true));
+ // Build the set of segments which are: in the desc mesh of the skin of the 3D mesh (M0) **and** in the desc mesh of the M1 group:
+ // (the U-shaped polyline described above)
+ MCUMesh m1IntersecSkin = static_cast<MEDCouplingUMesh *>(m0skinDesc->buildPartOfMySelf(validIds->begin(), validIds->end(), true));
+ // Its boundary nodes should no be duplicated (this is for example the tip of the crack inside the cube described above)
DAInt notDuplSkin = m1IntersecSkin->findBoundaryNodes();
DAInt fNodes1 = fNodes->buildSubstraction(notDuplSkin);
+
+ // Specific logic to handle singular points :
+ // - a point on this U-shape line used in a cell which has no face in common with M1 is deemed singular.
+ // - indeed, if duplicated, such a point would lead to the duplication of a cell which has no face touching M1 ! The
+ // algorithm would be duplicating too much ...
+ // This is a costly algorithm so only go into it if a simple (non sufficient) criteria is met: a node connected to more than 3 segs in meshM2:
+ dnu1=DataArrayIdType::New(), dnu2=DataArrayIdType::New(), dnu3=DataArrayIdType::New(), rdit0=DataArrayIdType::New();
+ MCUMesh meshM2Desc = meshM2->buildDescendingConnectivity(dnu1, dnu2, dnu3, rdit0); // a mesh made of node cells
+ dnu1=0;dnu2=0;dnu3=0;
+ dsi = rdit0->deltaShiftIndex(); rdit0=0;
+ DAInt singPoints = dsi->findIdsNotInRange(-1,4) ; dsi=0;// points connected to (strictly) more than 3 segments
+ if (singPoints->getNumberOfTuples())
+ {
+ DAInt boundNodes = m1IntersecSkin->computeFetchedNodeIds();
+ // If a point on this U-shape line is connected to cells which do not share any face with M1, then it
+ // should not be duplicated
+ // 1. Extract N D cells touching U-shape line:
+ DAInt cellsAroundBN = getCellIdsLyingOnNodes(boundNodes->begin(), boundNodes->end(), false); // false= take cell in, even if not all nodes are in dupl
+ MCUMesh mAroundBN = static_cast<MEDCouplingUMesh *>(this->buildPartOfMySelf(cellsAroundBN->begin(), cellsAroundBN->end(), true));
+ DAInt descBN=DataArrayIdType::New(), descIBN=DataArrayIdType::New(), revDescBN=DataArrayIdType::New(), revDescIBN=DataArrayIdType::New();
+ MCUMesh mAroundBNDesc = mAroundBN->buildDescendingConnectivity(descBN,descIBN,revDescBN,revDescIBN);
+ // 2. Identify cells in sub-mesh mAroundBN which have a face in common with M1
+ DataArrayIdType *idsOfM1BNt;
+ mAroundBNDesc->areCellsIncludedIn(otherDimM1OnSameCoords,2, idsOfM1BNt);
+ DAInt idsOfM1BN(idsOfM1BNt);
+ mcIdType nCells=mAroundBN->getNumberOfCells(), nCellsDesc=mAroundBNDesc->getNumberOfCells();
+ DAInt idsTouch=DataArrayIdType::New(); idsTouch->alloc(0,1);
+ const mcIdType *revDescIBNP=revDescIBN->begin(), *revDescBNP=revDescBN->begin();
+ for(const auto& v: *idsOfM1BN)
+ {
+ if (v >= nCellsDesc) // Keep valid match only
+ continue;
+ mcIdType idx0 = revDescIBNP[v];
+ // Keep the two cells on either side of the face v of M1:
+ mcIdType c1=revDescBNP[idx0], c2=revDescBNP[idx0+1];
+ idsTouch->pushBackSilent(c1); idsTouch->pushBackSilent(c2);
+ }
+ // 3. Build complement
+ DAInt idsTouchCompl = idsTouch->buildComplement(nCells);
+ MCUMesh mAroundBNStrict = static_cast<MEDCouplingUMesh *>(mAroundBN->buildPartOfMySelf(idsTouchCompl->begin(), idsTouchCompl->end(), true));
+ DAInt nod3 = mAroundBNStrict->computeFetchedNodeIds();
+ DAInt inters = boundNodes->buildIntersection(nod3);
+ fNodes1 = fNodes1->buildSubstraction(inters); // reminder: fNodes1 represent nodes that need dupl.
+ }
notDup = xtrem->buildSubstraction(fNodes1);
}
- else
+ else // if (validIds-> ...)
notDup = xtrem->buildSubstraction(fNodes);
}
- else
+ else // if (3D ...)
notDup = xtrem->buildSubstraction(fNodes);
- // Now compute cells around group (i.e. cells where we will do the propagation to identify the two sub-sets delimited by the group)
- DAInt m1Nodes = otherDimM1OnSameCoords.computeFetchedNodeIds();
+ DAInt m1Nodes = otherDimM1OnSameCoords->computeFetchedNodeIds();
DAInt dupl = m1Nodes->buildSubstraction(notDup);
- DAInt cellsAroundGroup = getCellIdsLyingOnNodes(dupl->begin(), dupl->end(), false); // false= take cell in, even if not all nodes are in notDup
+ return dupl.retn();
+}
- //
- 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();
- 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;
- 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;
- 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;
- // 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 neigh00(tmp0);
- 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);
- hitCells->fillWithValue(-1);
- DAInt cellsToModifyConn0_torenum = DataArrayInt::New();
- cellsToModifyConn0_torenum->alloc(0,1);
- while (nIter < nIterMax)
- {
- DAInt t = hitCells->findIdsEqual(-1);
- if (!t->getNumberOfTuples())
- break;
- // Connex zone without the crack (to compute the next seed really)
- int 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++)
- 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);
- // 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);
- DAInt intersec = nonHitCells->buildIntersection(comple);
- if (intersec->getNumberOfTuples())
- { seed = intersec->getIJ(0,0); }
- else
- { break; }
- nIter++;
+
+/*!
+ * This method expects that \b this and \b otherDimM1OnSameCoords share the same coordinates array.
+ * otherDimM1OnSameCoords->getMeshDimension() is expected to be equal to this->getMeshDimension()-1.
+ * This method is part of the MEDFileUMesh::buildInnerBoundaryAlongM1Group() algorithm.
+ * Given a set of nodes to duplicate, this method identifies which cells should have their connectivity modified
+ * to produce the inner boundary. It is typically called after findNodesToDuplicate().
+ *
+ * \param [in] otherDimM1OnSameCoords a mesh lying on the same coords than \b this and with a mesh dimension equal to those of \b this minus 1.
+ * \param [in] nodeIdsToDuplicateBg node ids needed to be duplicated, as returned by findNodesToDuplicate.
+ * \param [in] nodeIdsToDuplicateEnd node ids needed to be duplicated, as returned by findNodesToDuplicate.
+ * \param [out] cellIdsNeededToBeRenum cell ids in \b this in which the renumber of nodes should be performed.
+ * \param [out] cellIdsNotModified cell ids in \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.
+ *
+ */
+void MEDCouplingUMesh::findCellsToRenumber(const MEDCouplingUMesh& otherDimM1OnSameCoords, const mcIdType *nodeIdsToDuplicateBg, const mcIdType *nodeIdsToDuplicateEnd,
+ DataArrayIdType *& cellIdsNeededToBeRenum, DataArrayIdType *& cellIdsNotModified) const
+{
+ using DAInt = MCAuto<DataArrayIdType>;
+ using MCUMesh = MCAuto<MEDCouplingUMesh>;
+
+ checkFullyDefined();
+ otherDimM1OnSameCoords.checkFullyDefined();
+ if(getCoords()!=otherDimM1OnSameCoords.getCoords())
+ throw INTERP_KERNEL::Exception("MEDCouplingUMesh::findCellsToRenumber: meshes do not share the same coords array !");
+ if(otherDimM1OnSameCoords.getMeshDimension()!=getMeshDimension()-1)
+ throw INTERP_KERNEL::Exception("MEDCouplingUMesh::findCellsToRenumber: the mesh given in other parameter must have this->getMeshDimension()-1 !");
+
+ // Degenerated case - no nodes to duplicate
+ if (nodeIdsToDuplicateBg == nodeIdsToDuplicateEnd)
+ {
+ cellIdsNeededToBeRenum = DataArrayIdType::New(); cellIdsNeededToBeRenum->alloc(0,1);
+ cellIdsNotModified = DataArrayIdType::New(); cellIdsNotModified->alloc(0,1);
+ return;
+ }
+
+ // Compute cell IDs of the mesh with cells that touch the M1 group with a least one node:
+ DAInt cellsAroundGroupLarge = getCellIdsLyingOnNodes(nodeIdsToDuplicateBg, nodeIdsToDuplicateEnd, false); // false= take cell in, even if not all nodes are in dupl
+ MCUMesh mAroundGrpLarge=static_cast<MEDCouplingUMesh *>(buildPartOfMySelf(cellsAroundGroupLarge->begin(),cellsAroundGroupLarge->end(),true));
+ mcIdType nCellsLarge=cellsAroundGroupLarge->getNumberOfTuples();
+ DAInt descL=DataArrayIdType::New(),descIL=DataArrayIdType::New(),revDescL=DataArrayIdType::New(),revDescIL=DataArrayIdType::New();
+ MCUMesh mArGrpLargeDesc=mAroundGrpLarge->buildDescendingConnectivity(descL,descIL,revDescL,revDescIL);
+ const mcIdType *descILP=descIL->begin(), *descLP=descL->begin();
+ DataArrayIdType *idsOfM1t;
+ mArGrpLargeDesc->areCellsIncludedIn(&otherDimM1OnSameCoords,2, idsOfM1t);
+ DAInt idsOfM1Large(idsOfM1t);
+ mcIdType nL = mArGrpLargeDesc->getNumberOfCells();
+
+ // Computation of the neighbor information of the mesh WITH the crack (some neighbor links are removed):
+ // 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):
+ DAInt descLTrunc = descL->deepCopy(), descILTrunc = descIL->deepCopy();
+ DataArrayIdType::RemoveIdsFromIndexedArrays(idsOfM1Large->begin(), idsOfM1Large->end(),descLTrunc,descILTrunc);
+ DataArrayIdType *neight=0, *neighIt=0;
+ MEDCouplingUMesh::ComputeNeighborsOfCellsAdv(descLTrunc,descILTrunc,revDescL,revDescIL, neight, neighIt);
+ DAInt neighL(neight), neighIL(neighIt);
+
+ DAInt hitCellsLarge = DataArrayIdType::New(); hitCellsLarge->alloc(nCellsLarge,1);
+ hitCellsLarge->fillWithValue(0); // 0 : not hit, +1: one side of the crack, -1: other side of the crack,
+ mcIdType* hitCellsLargeP = hitCellsLarge->rwBegin();
+
+ // Now loop on the faces of the M1 group and fill spread zones on either side of the crack:
+ const mcIdType *revDescILP=revDescIL->begin(), *revDescLP=revDescL->begin();
+ for(const auto& v: *idsOfM1Large)
+ {
+ if (v >= nL) continue; // Keep valid match only - see doc of areCellsIncludedIn()
+ mcIdType idx0 = revDescILP[v];
+ // Retrieve the two cells on either side of the face v of M1:
+ mcIdType c1=revDescLP[idx0], c2=revDescLP[idx0+1];
+ std::map<mcIdType, mcIdType> toOther = {{c1, c2}, {c2, c1}};
+ // Handle the spread zones on the two sides of the crack:
+ for (const auto c: {c1, c2})
+ {
+ if (hitCellsLargeP[c]) continue;
+ // Identify connex zone around this cell - if we find a value already assigned there, use it.
+ mcIdType dnu;
+ DAInt spreadZone = MEDCouplingUMesh::ComputeSpreadZoneGraduallyFromSeed(&c, &c+1, neighL,neighIL, -1, dnu);
+ std::set<mcIdType> sv;
+ for (const mcIdType& s: *spreadZone)
+ if (hitCellsLargeP[s]) sv.insert(hitCellsLargeP[s]);
+ if (sv.size() > 1)
+ // Strange: we find in the same spread zone a +1 and -1 !
+ throw INTERP_KERNEL::Exception("MEDCouplingUMesh::findCellsToRenumber: internal error #0 - conflicting values - should not happen!");
+ // If a valid value was found, use it:
+ mcIdType val = sv.size()==1 ? *sv.begin() : 0;
+ // Hopefully this does not conflict with an potential value on the other side:
+ mcIdType other = toOther[c];
+ if (hitCellsLargeP[other])
+ {
+ if(val && hitCellsLargeP[other] != -val)
+ throw INTERP_KERNEL::Exception("MEDCouplingUMesh::findCellsToRenumber: internal error #1 - conflicting values - should not happen!");;
+ // We do not yet have a value, but other side has one. Use it!
+ if(!val) val = -hitCellsLargeP[other];
+ }
+ // Cover first initialisation:
+ if (!val) val = 1;
+ // And finally, fill the current spread zone:
+ for(const mcIdType& s: *spreadZone) hitCellsLargeP[s] = val;
+ }
}
- if (nIter >= nIterMax)
- throw INTERP_KERNEL::Exception("MEDCouplingUMesh::findNodesToDuplicate(): internal error - too many iterations.");
- DAInt cellsToModifyConn1_torenum=cellsToModifyConn0_torenum->buildComplement(neighI00->getNumberOfTuples()-1);
- cellsToModifyConn0_torenum->transformWithIndArr(cellsAroundGroup->begin(),cellsAroundGroup->end());
- cellsToModifyConn1_torenum->transformWithIndArr(cellsAroundGroup->begin(),cellsAroundGroup->end());
+ DAInt cellsRet1 = hitCellsLarge->findIdsEqual(1);
+ DAInt cellsRet2 = hitCellsLarge->findIdsEqual(-1);
+
+ if (cellsRet1->getNumberOfTuples() + cellsRet2->getNumberOfTuples() != cellsAroundGroupLarge->getNumberOfTuples())
+ {
+ DAInt nonHitCells = hitCellsLarge->findIdsEqual(0); // variable kept for debug ...
+ throw INTERP_KERNEL::Exception("MEDCouplingUMesh::findCellsToRenumber: Some cells not hit - Internal error should not happen");
+ }
+ cellsRet1->transformWithIndArr(cellsAroundGroupLarge->begin(),cellsAroundGroupLarge->end());
+ cellsRet2->transformWithIndArr(cellsAroundGroupLarge->begin(),cellsAroundGroupLarge->end());
//
- cellIdsNeededToBeRenum=cellsToModifyConn0_torenum.retn();
- cellIdsNotModified=cellsToModifyConn1_torenum.retn();
- nodeIdsToDuplicate=dupl.retn();
+ cellIdsNeededToBeRenum=cellsRet1.retn();
+ cellIdsNotModified=cellsRet2.retn();
}
/*!
* \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);
}
/*!
* \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];
*
* \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;
* \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 ).
*/
-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;
}
* 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
+ * \param check whether to check content of old2NewBg
*/
-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));
}
/*!
* \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.
* \throw If the coordinates array is not set.
* \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 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::bind(std::not_equal_to<mcIdType>(),std::placeholders::_1,-1)));
}
/*!
* \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;
}
* \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.
+ * \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;
* 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;
}
/*!
* Second step of serialization process.
* \param tinyInfo must be equal to the result given by getTinySerializationInformation method.
- * \param a1
- * \param a2
- * \param littleStrings
+ * \param a1 DataArrayDouble
+ * \param a2 DataArrayDouble
+ * \param littleStrings string vector
*/
-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));
+ std::transform(area_vol,area_vol+nbelem,area_vol,[](double c){return fabs(c);});
}
else
{
* \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));
+ std::transform(array->getPointer(),area_vol,array->getPointer(),[](double c){return fabs(c);});
}
else
{
MCAuto<MEDCouplingFieldDouble> tmp=getMeasureField(isAbs);
std::string name="MeasureOnNodeOfMesh_";
name+=getName();
- int nbNodes=getNumberOfNodes();
+ mcIdType nbNodes=getNumberOfNodes();
+ MCAuto<DataArrayDouble> nnpc;
+ {
+ MCAuto<DataArrayIdType> tmp2(computeNbOfNodesPerCell());
+ nnpc=tmp2->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();
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));
+ std::transform(vals,vals+3,vals,std::bind(std::multiplies<double>(),std::placeholders::_1,1./n));
}
}
else
{
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));
+ std::transform(tmp,tmp+2,tmp,std::bind(std::multiplies<double>(),std::placeholders::_1,1./n));
*vals++=-tmp[1];
*vals++=tmp[0];
}
* \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));
+ std::transform(vals,vals+3,vals,std::bind(std::multiplies<double>(),std::placeholders::_1,1./n));
}
}
else
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));
+ std::transform(tmp,tmp+2,tmp,std::bind(std::multiplies<double>(),std::placeholders::_1,1./n));
*vals++=-tmp[1];
*vals++=tmp[0];
}
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
* \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);
+ //Marking all 1D cells that contained at least one node located on the plane
+ //the intersection between those cells and the plane, which consist of the nodes previously tagged, thus don't need to be computed afterwards
+ //(if said intersection is computed in MEDCouplingUMesh::split3DCurveWithPlane, then we might create additional nodes
+ //due to accuracy errors when the needed nodes already exist)
+ mDesc1->fillCellIdsToKeepFromNodeIds(&nodes[0],&nodes[0]+nodes.size(),false,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
* \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>());
* 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();
}
* \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);
* 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;
* point, for more points getCellsContainingPoints() is recommended as it is
* faster.
* \param [in] pos - array of coordinates of the ball central point.
- * \param [in] eps - ball radius.
+ * \param [in] eps - ball radius (i.e. the precision) relative to max dimension along X, Y or Z of the the considered cell bounding box.
* \param [out] elts - vector returning ids of the found cells. It is cleared
* before inserting ids.
* \throw If the coordinates array is not set.
* \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)
* X0,Y0,Z0,X1,Y1,Z1,... Size of the array must be \a
* 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 [in] eps - ball radius (i.e. the precision) relative to max dimension along X, Y or Z of the the considered cell bounding box.
* \param [out] elts - vector returning ids of found cells.
* \param [out] eltsIndex - an array, of length \a nbOfPoints + 1,
* dividing cell ids in \a elts into groups each referring to one
* \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();
* \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));
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;
}
*
* \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 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])
* \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))
{
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)
{
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)
{
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.
* \throw If \a this->getMeshDimension() != 3.
* \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 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)
+ * \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);
}
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)
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)
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)
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);
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++)
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())
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;
};
}
* 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 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.
+ * 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;
* 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 [in] profile list of IDs constituing the 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,
* \a idsInPflPerType[i] stores the tuple ids in \a profile that correspond to the geometric type code[3*i+0]
* 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;
}
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);
/*!
* Convert the nodal connectivity of the mesh so that all the cells are of dynamic types (polygon or quadratic
* polygon). This returns the corresponding new nodal connectivity in \ref numbering-indirect format.
- * \param nodalConn
- * \param nodalConnI
+ * \param nodalConn nodal connectivity
+ * \param nodalConnIndex nodal connectivity indices
*/
-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::bind(std::plus<mcIdType>(),std::placeholders::_1,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
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));
+ std::transform(ptToFill,ptToFill+spaceDim,ptToFill,std::bind(std::multiplies<double>(),std::placeholders::_1,1./(double)nbOfNodesInCell));
else
{
std::ostringstream oss; oss << "MEDCouplingUMesh::computeIsoBarycenterOfNodesPerCell : on cell #" << i << " presence of cell with no nodes !";
}
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>());
}
}
if(!s.empty())
- std::transform(ptToFill,ptToFill+spaceDim,ptToFill,std::bind2nd(std::multiplies<double>(),1./(double)s.size()));
+ std::transform(ptToFill,ptToFill+spaceDim,ptToFill,std::bind(std::multiplies<double>(),std::placeholders::_1,1./(double)s.size()));
else
{
std::ostringstream oss; oss << "MEDCouplingUMesh::computeIsoBarycenterOfNodesPerCell : on polyhedron cell #" << i << " there are no nodes !";
* \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;
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);
- std::transform(dd,dd+3,dd,std::bind2nd(std::multiplies<double>(),1./(double)nbOfNodesInCell));
+ mcIdType nbOfNodesInCell(nodalI[1]-nodalI[0]-1);
+ std::transform(dd,dd+3,dd,std::bind(std::multiplies<double>(),std::placeholders::_1,1./(double)nbOfNodesInCell));
std::copy(dd,dd+3,matrix+4*2);
INTERP_KERNEL::inverseMatrix(matrix,4,matrix2);
retPtr[0]=matrix2[3]; retPtr[1]=matrix2[7]; retPtr[2]=matrix2[11]; retPtr[3]=matrix2[15];
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::bind(std::plus<mcIdType>(),std::placeholders::_1,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;
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);
/*!
* 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.};
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
{
- // Use all points if quadratic (taking only linear points might lead to issues if the linearized version of the
+ // 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)
- sz /= 2;
+ 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];
/*!
* 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)
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.;
}
*
* \param [in] eps is a relative precision that allows to establish if some 3D plane are coplanar or not.
* \param [in] coords the coordinates with nb of components exactly equal to 3
- * \param [in] begin begin of the nodal connectivity (geometric type included) of a single polyhedron cell
- * \param [in] end end of nodal connectivity of a single polyhedron cell (excluded)
+ * \param [in] index begin of the nodal connectivity (geometric type included) of a single polyhedron cell
* \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);
}
* \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())
{
nbOfEdgesInFace=std::distance(bgFace,endFace);
if(!isPerm[i])
{
- bool b;
+ bool b=false;
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; }
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++)
*
* \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)
*
* \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);
+ std::unique_ptr<mcIdType[]> medcoupling2vtkTypeTraducer_mcIdType(new mcIdType[MEDCOUPLING2VTKTYPETRADUCER_LGTH]);
+ for(auto ii = 0; ii<MEDCOUPLING2VTKTYPETRADUCER_LGTH ; ++ii)
+ medcoupling2vtkTypeTraducer_mcIdType[ii] = MEDCOUPLING2VTKTYPETRADUCER[ii]!=MEDCOUPLING2VTKTYPETRADUCER_NONE?MEDCOUPLING2VTKTYPETRADUCER[ii] : -1;
+ types->transformWithIndArr(medcoupling2vtkTypeTraducer_mcIdType.get(),medcoupling2vtkTypeTraducer_mcIdType.get()+MEDCOUPLING2VTKTYPETRADUCER_LGTH);
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;
+
+ //for piecewise meshes made up of closed parts
+ bool segmentAlreadyTreated = (std::find(linePiece.begin(), linePiece.end(), activeSeg) != linePiece.end());
+ if(segmentAlreadyTreated)
+ break;
}
}
// 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())
startSeg = *(edgeSet.begin());
+
}
while (!edgeSet.empty());
return result.retn();
* \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 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 !");
*
* \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.
* \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.
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];
* \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] 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.
* \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)
else
return 0;
}
+
+/// @cond INTERNAL
+
+namespace MEDCouplingImpl
+{
+ const mcIdType theUndefID = std::numeric_limits< mcIdType >::max(); //!< undefined cell id
+
+ //================================================================================
+ /*!
+ * \brief Encode a cell id and a mesh index into a code
+ * \param [in] id - cell id
+ * \param [in] iMesh - mesh index [0,1]
+ * \return mcIdType - code
+ */
+ //================================================================================
+
+ mcIdType encodeID( mcIdType id, int iMesh )
+ {
+ return ( id + 1 ) * ( iMesh ? -1 : 1 );
+ }
+ //================================================================================
+ /*!
+ * \brief Return cell id and mesh index by a given id
+ * \param [in] id - code of a cell in a mesh
+ * \param [out] iMesh - returned mesh index
+ * \return mcIdType - cell id
+ */
+ //================================================================================
+
+ mcIdType decodeID( mcIdType id, int& iMesh )
+ {
+ iMesh = ( id < 0 );
+ return std::abs( id ) - 1;
+ }
+
+ //================================================================================
+ /*!
+ * \brief return another face sharing two given nodes of a face edge
+ * \param [in] n0 - 1st node of the edge
+ * \param [in] n1 - 2nd node of the edge
+ * \param [in] inputFaceID - face including \a n0 andf \a n2
+ * \param [in] mesh - object and reference meshes
+ * \param [in] revNodal - reverse nodal connectivity of the two meshes
+ * \param [in] revNodalIndx - index of reverse nodal connectivity of the two meshes
+ * \param [out] facesByEdge - return another face including \a n0 andf \a n2
+ * \param [out] equalFaces - return faces equal to facesByEdge
+ */
+ //================================================================================
+
+ void getFacesOfEdge( mcIdType n0,
+ mcIdType n1,
+ mcIdType inputFaceID,
+ MEDCouplingUMesh* mesh[],
+ MCAuto<DataArrayIdType> revNodal[],
+ MCAuto<DataArrayIdType> revNodalIndx[],
+ std::vector< mcIdType >& facesByEdge,
+ std::vector< mcIdType >& equalFaces)
+ {
+ // find faces sharing the both nodes of edge
+
+ facesByEdge.clear();
+ size_t prevNbF; // nb faces found in 0-th mesh
+ for ( int iM = 0; iM < 2; ++iM )
+ {
+ const mcIdType * revInd = revNodalIndx[ iM ]->begin();
+ const mcIdType * rev = revNodal [ iM ]->begin();
+
+ mcIdType nbRevFaces0 = revInd[ n0 + 1 ] - revInd[ n0 ];
+ mcIdType nbRevFaces1 = revInd[ n1 + 1 ] - revInd[ n1 ];
+
+ prevNbF = facesByEdge.size();
+ facesByEdge.resize( prevNbF + std::max( nbRevFaces0, nbRevFaces1 ));
+
+ auto it = std::set_intersection( rev + revInd[ n0 ],
+ rev + revInd[ n0 ] + nbRevFaces0,
+ rev + revInd[ n1 ],
+ rev + revInd[ n1 ] + nbRevFaces1,
+ facesByEdge.begin() + prevNbF );
+ facesByEdge.resize( it - facesByEdge.begin() );
+ }
+
+ // facesByEdge now contains at least the 'inputFaceID'
+ // check if there are other faces
+
+ size_t nbF = facesByEdge.size();
+ if ( nbF > 1 )
+ {
+ if ( prevNbF > 0 && prevNbF < nbF ) // faces found in both meshes
+ {
+ // remove from facesByEdge equal faces in different meshes
+ const mcIdType *conn [2] = { mesh[0]->getNodalConnectivity()->getConstPointer(),
+ mesh[1]->getNodalConnectivity()->getConstPointer() };
+ const mcIdType *connI[2] = { mesh[0]->getNodalConnectivityIndex()->getConstPointer(),
+ mesh[1]->getNodalConnectivityIndex()->getConstPointer() };
+ for ( size_t i0 = 0; i0 < prevNbF; ++i0 )
+ {
+ if ( facesByEdge[ i0 ] == theUndefID )
+ continue;
+ mcIdType objFaceID = MEDCouplingImpl::encodeID( facesByEdge[ i0 ], 0 );
+ bool isInputFace = ( objFaceID == inputFaceID );
+
+ for ( size_t i1 = prevNbF; i1 < facesByEdge.size(); ++i1 )
+ {
+ if ( facesByEdge[ i1 ] == theUndefID )
+ continue;
+
+ mcIdType f0 = facesByEdge[ i0 ];
+ mcIdType f1 = facesByEdge[ i1 ];
+ size_t nbNodes0 = connI[0][ f0 + 1 ] - connI[0][ f0 ] - 1;
+ size_t nbNodes1 = connI[1][ f1 + 1 ] - connI[1][ f1 ] - 1;
+ if ( nbNodes0 != nbNodes1 )
+ continue;
+
+ const mcIdType * fConn0 = conn[0] + connI[0][ f0 ] + 1;
+ const mcIdType * fConn1 = conn[1] + connI[1][ f1 ] + 1;
+ if ( std::equal( fConn0, fConn0 + nbNodes0, fConn1 ))
+ {
+ // equal faces; remove an object one
+ mcIdType refFaceID = MEDCouplingImpl::encodeID( facesByEdge[ i1 ], 1 );
+ if ( refFaceID == inputFaceID )
+ isInputFace = true;
+
+ if ( std::find( equalFaces.begin(),
+ equalFaces.end(), objFaceID ) == equalFaces.end() )
+ equalFaces.push_back( objFaceID );
+
+ facesByEdge[ i0 ] = theUndefID;
+ if ( isInputFace )
+ facesByEdge[ i1 ] = theUndefID;
+ break;
+ }
+ }
+ if ( isInputFace )
+ facesByEdge[ i0 ] = theUndefID;
+ }
+ }
+ }
+
+ nbF = facesByEdge.size();
+ for ( size_t i = 0; i < facesByEdge.size(); ++i )
+ {
+ if ( facesByEdge[ i ] != theUndefID )
+ {
+ facesByEdge[ i ] = MEDCouplingImpl::encodeID( facesByEdge[ i ], i >= prevNbF );
+ if ( facesByEdge[ i ] == inputFaceID )
+ facesByEdge[ i ] = theUndefID;
+ }
+ nbF -= ( facesByEdge[ i ] == theUndefID );
+ }
+
+ if ( nbF > 1 )
+ return; // non-manifold
+
+ if ( nbF < 1 )
+ {
+ facesByEdge.clear();
+ }
+ else // nbF == 1, set a found face first
+ {
+ if ( facesByEdge[ 0 ] == theUndefID )
+ {
+ for ( size_t i = 1; i < facesByEdge.size(); ++i )
+ if ( facesByEdge[ i ] != theUndefID )
+ {
+ facesByEdge[ 0 ] = facesByEdge[ i ];
+ break;
+ }
+ }
+ facesByEdge.resize( 1 );
+ }
+ return;
+ }
+
+ //================================================================================
+ /*!
+ * \brief Remove a face from nodal reversed connectivity
+ * \param [in] node - a node of the face
+ * \param [in] face - the face
+ * \param [in.out] revNodal - reverse nodal connectivity
+ * \param [in,out] revNodalIndx - reverse nodal connectivity index
+ */
+ //================================================================================
+
+ void removeFromRevNodal( mcIdType node,
+ mcIdType face,
+ MCAuto<DataArrayIdType>& revNodal,
+ MCAuto<DataArrayIdType>& revNodalIndx)
+ {
+ mcIdType* fBeg = revNodal->getPointer() + revNodalIndx->getIJ( node, 0 );
+ mcIdType* fEnd = revNodal->getPointer() + revNodalIndx->getIJ( node + 1, 0);
+ auto it = std::find( fBeg, fEnd, face );
+ if ( it != fEnd )
+ {
+ for ( auto it2 = it + 1; it2 < fEnd; ++it2 ) // keep faces sorted
+ *( it2 - 1 ) = *it2;
+
+ *( fEnd - 1 ) = theUndefID;
+ }
+ }
+
+ //================================================================================
+ /*!
+ * \brief Check order of two nodes in a given face
+ * \param [inout] n0 - node 1
+ * \param [inout] n1 - node 2
+ * \param [inout] iFEnc - face
+ * \param [inout] mesh - mesh
+ * \return bool - true if the nodes are in [ .., n1, n0, ..] order in face
+ */
+ //================================================================================
+
+ bool isReverseOrder( mcIdType n0,
+ mcIdType n1,
+ mcIdType iFEnc,
+ MEDCouplingUMesh* mesh[] )
+ {
+ int iMesh;
+ mcIdType iF = decodeID( iFEnc, iMesh );
+
+ const mcIdType *conn = mesh[ iMesh ]->getNodalConnectivity()->getConstPointer();
+ const mcIdType *connI = mesh[ iMesh ]->getNodalConnectivityIndex()->getConstPointer();
+
+ auto it0 = std::find( conn + connI[ iF ] + 1,
+ conn + connI[ iF + 1 ],
+ n0 );
+ auto it1 = std::find( conn + connI[ iF ] + 1,
+ conn + connI[ iF + 1 ],
+ n1 );
+ long i0 = it0 - conn;
+ long i1 = it1 - conn;
+
+ bool isRev = ( std::abs( i1 - i0 ) == 1 ) ? i1 < i0 : i0 < i1;
+ return isRev;
+ }
+
+ //================================================================================
+ /*!
+ * \brief Change orientation of a face in one of given meshes
+ * \param [in] iFEnc - face ID also encoding a mesh index
+ * \param [in,out] mesh - object and reference meshes
+ */
+ //================================================================================
+
+ void reverseFace( mcIdType iFEnc, MEDCouplingUMesh* mesh[] )
+ {
+ int iMesh;
+ mcIdType face = decodeID( iFEnc, iMesh );
+
+ mcIdType *conn = mesh[ iMesh ]->getNodalConnectivity()->getPointer();
+ mcIdType *connI = mesh[ iMesh ]->getNodalConnectivityIndex()->getPointer();
+
+ const INTERP_KERNEL::CellModel& cm =
+ INTERP_KERNEL::CellModel::GetCellModel( mesh[iMesh]->getTypeOfCell( face ));
+
+ cm.changeOrientationOf2D( conn + connI[ face ] + 1,
+ (unsigned int)( connI[ face + 1 ] - connI[ face ] - 1 ));
+ return;
+ }
+}
+
+/// @endcond
+
+//================================================================================
+/*!
+ * \brief Orient cells of \a this 2D mesh equally to \a refFaces
+ * \param [in] refFaces - 2D mesh containing correctly oriented faces. It is optional.
+ * If there are no cells in \a refFaces or it is nullptr, then any face
+ * in \a this mesh is used as a reference
+ * \throw If \a this mesh is not well defined.
+ * \throw If \a this mesh or \refFaces are not 2D.
+ * \throw If \a this mesh and \refFaces do not share nodes.
+ * \throw If \a refFaces are not equally oriented.
+ * \throw If \a this mesh plus \a refFaces together form a non-manifold mesh.
+ *
+ * \if ENABLE_EXAMPLES
+ * \ref cpp_mcumesh_are2DCellsNotCorrectlyOriented "Here is a C++ example".<br>
+ * \ref py_mcumesh_are2DCellsNotCorrectlyOriented "Here is a Python example".
+ * \endif
+ */
+//================================================================================
+
+void MEDCouplingUMesh::orientCorrectly2DCells(const MEDCouplingUMesh* refFaces)
+{
+ checkConsistencyLight();
+ if ( getMeshDimension() != 2 )
+ throw INTERP_KERNEL::Exception("The mesh dimension must be 2");
+ if ( refFaces )
+ {
+ refFaces->checkConsistencyLight();
+ if ( refFaces->getMeshDimension() != 2 )
+ throw INTERP_KERNEL::Exception("The reference mesh dimension must be 2");
+ if ( getCoords() != refFaces->getCoords() )
+ throw INTERP_KERNEL::Exception("Object and reference meshes must share nodes ");
+ if ( refFaces->getNumberOfCells() == 0 )
+ refFaces = nullptr;
+ }
+ if ( getNumberOfCells() == 0 )
+ return;
+
+ enum { _OBJ, _REF };
+ MEDCouplingUMesh* mesh[2] = { this, const_cast< MEDCouplingUMesh* >( refFaces ) };
+ MCAuto<MEDCouplingUMesh> meshPtr;
+ if ( !mesh[_REF] )
+ {
+ meshPtr = mesh[_REF] = MEDCouplingUMesh::New();
+ mesh[_REF]->setCoords( mesh[_OBJ]->getCoords() );
+ mesh[_REF]->allocateCells(0);
+ mesh[_REF]->finishInsertingCells();
+ }
+ mcIdType nbFacesToCheck[2] = { mesh[_OBJ]->getNumberOfCells(),
+ mesh[_REF]->getNumberOfCells() };
+ std::vector< bool > isFaceQueued[ 2 ]; // enqueued faces of 2 meshes
+ isFaceQueued[_OBJ].resize( nbFacesToCheck[_OBJ] );
+ isFaceQueued[_REF].resize( nbFacesToCheck[_REF] );
+
+ MCAuto<DataArrayIdType> revNodal [2] = { DataArrayIdType::New(), DataArrayIdType::New() };
+ MCAuto<DataArrayIdType> revNodalIndx[2] = { DataArrayIdType::New(), DataArrayIdType::New() };
+ mesh[_OBJ]->getReverseNodalConnectivity( revNodal[_OBJ], revNodalIndx[_OBJ] );
+ mesh[_REF]->getReverseNodalConnectivity( revNodal[_REF], revNodalIndx[_REF] );
+
+ std::vector< mcIdType > faceNodes(4);
+ std::vector< mcIdType > facesByEdge(4), equalFaces;
+ std::vector< mcIdType > faceQueue; // starting faces with IDs counted from 1; negative ID mean a face in ref mesh
+
+ while ( nbFacesToCheck[_OBJ] + nbFacesToCheck[_REF] > 0 ) // until all faces checked
+ {
+ if ( faceQueue.empty() ) // all neighbors checked, find more faces to check
+ {
+ for ( int iMesh = 1; iMesh >= 0; --iMesh ) // on [ _REF, _OBJ ]
+ if ( nbFacesToCheck[iMesh] > 0 )
+ for ( mcIdType f = 0, nbF = mesh[iMesh]->getNumberOfCells(); f < nbF; ++f )
+ if ( !isFaceQueued[iMesh][f] )
+ {
+ faceQueue.push_back( MEDCouplingImpl::encodeID( f, iMesh ));
+ isFaceQueued[ iMesh ][ f ] = true;
+ iMesh = 0;
+ break;
+ }
+ if ( faceQueue.empty() )
+ break;
+ }
+
+ mcIdType fID = faceQueue.back();
+ faceQueue.pop_back();
+
+ int iMesh, iMesh2;
+ mcIdType refFace = MEDCouplingImpl::decodeID( fID, iMesh );
+
+ nbFacesToCheck[iMesh]--;
+
+ equalFaces.clear();
+ faceNodes.clear();
+ mesh[iMesh]->getNodeIdsOfCell( refFace, faceNodes );
+ const INTERP_KERNEL::CellModel& cm = INTERP_KERNEL::CellModel::GetCellModel( mesh[iMesh]->getTypeOfCell( refFace ));
+ const int nbEdges = cm.getNumberOfSons();
+
+ // loop on edges of the refFace
+ mcIdType n0 = faceNodes[ nbEdges - 1 ]; // 1st node of edge
+ for ( int edge = 0; edge < nbEdges; ++edge )
+ {
+ mcIdType n1 = faceNodes[ edge ]; // 2nd node of edge
+
+ // get faces sharing the edge
+ MEDCouplingImpl::getFacesOfEdge( n0, n1, fID, mesh, revNodal, revNodalIndx,
+ facesByEdge, equalFaces );
+
+ if ( facesByEdge.size() > 1 )
+ THROW_IK_EXCEPTION("Non-manifold mesh at edge " << n0+1 << " - " << n1+1);
+
+ if ( facesByEdge.size() == 1 )
+ {
+ // compare orientation of two faces
+ //
+ if ( !MEDCouplingImpl::isReverseOrder( n0, n1, facesByEdge[0], mesh ))
+ {
+ if ( facesByEdge[0] < 0 ) // in the ref mesh
+ throw INTERP_KERNEL::Exception("Different orientation of reference faces");
+
+ MEDCouplingImpl::reverseFace( facesByEdge[0], mesh );
+ }
+ mcIdType face2 = MEDCouplingImpl::decodeID( facesByEdge[0], iMesh2 );
+ if ( !isFaceQueued[iMesh2][face2] )
+ {
+ isFaceQueued[iMesh2][face2] = true;
+ faceQueue.push_back( facesByEdge[0] );
+ }
+ }
+ n0 = n1;
+ }
+
+ // remove face and equalFaces from revNodal in order not to treat them again
+ equalFaces.push_back( fID );
+ for ( mcIdType face : equalFaces )
+ {
+ mcIdType f = MEDCouplingImpl::decodeID( face, iMesh2 );
+ const mcIdType *conn = mesh[iMesh2]->getNodalConnectivity()->getConstPointer();
+ const mcIdType *connI = mesh[iMesh2]->getNodalConnectivityIndex()->getConstPointer();
+ mcIdType nbNodes = connI[ f + 1 ] - connI[ f ] - 1;
+ for ( const mcIdType* n = conn + connI[ f ] + 1, *nEnd = n + nbNodes; n < nEnd; ++n )
+
+ MEDCouplingImpl::removeFromRevNodal( *n, f, // not to treat f again
+ revNodal[ iMesh2 ], revNodalIndx[ iMesh2 ] );
+ }
+
+ } // while() until all faces checked
+
+ return;
+}
