new_elems_right.reserve(nbelems/2+1);
double max_left = -std::numeric_limits<double>::max();
double min_right= std::numeric_limits<double>::max();
- for (int i=0; i<nbelems;i++)
+ for (ConnType i=0; i<nbelems;i++)
{
- int elem;
+ ConnType elem;
if (elems!=0)
elem= elems[i];
else
tmp=0;
if(!new_elems_left.empty())
tmp=&(new_elems_left[0]);
- _left=new BBTree(bbs, tmp, level+1, (int)new_elems_left.size(),_epsilon);
+ _left=new BBTree(bbs, tmp, level+1, (ConnType)new_elems_left.size(),_epsilon);
tmp=0;
if(!new_elems_right.empty())
tmp=&(new_elems_right[0]);
- _right=new BBTree(bbs, tmp, level+1, (int)new_elems_right.size(),_epsilon);
+ _right=new BBTree(bbs, tmp, level+1, (ConnType)new_elems_right.size(),_epsilon);
}
// terminal node : return list of elements intersecting bb
if (_terminal)
{
- for (int i=0; i<_nbelems; i++)
+ for (mcIdType i=0; i<_nbelems; i++)
{
const double* const bb_ptr=_bb+_elems[i]*2*dim;
bool intersects = true;
/*!
* This method is very close to getIntersectingElems except that it returns number of elems instead of elems themselves.
*/
- int getNbOfIntersectingElems(const double* bb)
+ ConnType getNbOfIntersectingElems(const double* bb)
{
// terminal node : return list of elements intersecting bb
- int ret(0);
+ ConnType ret(0);
if (_terminal)
{
- for (int i=0; i<_nbelems; i++)
+ for (ConnType i=0; i<_nbelems; i++)
{
const double* const bb_ptr=_bb+_elems[i]*2*dim;
bool intersects = true;
- int size()
+ ConnType size()
{
if (_terminal) return _nbelems;
return _left->size()+_right->size();
double _max_left;
double _min_right;
const double *_bb;
- std::vector<int> _elems;
+ std::vector<mcIdType> _elems;
double *_terminal;
- int _nbelems;
+ mcIdType _nbelems;
static const int MIN_NB_ELEMS=15;
static const int MAX_LEVEL=20;
public:
- BBTreeDst(const double* bbs, int* elems, int level, int nbelems):
+ BBTreeDst(const double* bbs, mcIdType* elems, int level, mcIdType nbelems):
_left(0),_right(0),_level(level),_bb(bbs),_terminal(0),_nbelems(nbelems)
{
if((nbelems < MIN_NB_ELEMS || level> MAX_LEVEL))
_terminal=new double[2*dim];
_elems.resize(nbelems);
- for (int i=0; i<nbelems; i++)
+ for (mcIdType i=0; i<nbelems; i++)
_elems[i]=elems?elems[i]:i;
if(_terminal)
{
return ;
}
double *nodes=new double[nbelems];
- for (int i=0; i<nbelems; i++)
+ for (mcIdType i=0; i<nbelems; i++)
nodes[i]=bbs[_elems[i]*dim*2+(level%dim)*2];
std::nth_element<double*>(nodes, nodes+nbelems/2, nodes+nbelems);
double median = *(nodes+nbelems/2);
delete [] nodes;
- std::vector<int> new_elems_left;
- std::vector<int> new_elems_right;
+ std::vector<mcIdType> new_elems_left;
+ std::vector<mcIdType> new_elems_right;
new_elems_left.reserve(nbelems/2+1);
new_elems_right.reserve(nbelems/2+1);
double max_left = -std::numeric_limits<double>::max();
double min_right= std::numeric_limits<double>::max();
- for(int i=0; i<nbelems;i++)
+ for(mcIdType i=0; i<nbelems;i++)
{
- int elem;
+ mcIdType elem;
if (elems!=0)
elem= elems[i];
else
}
_max_left=max_left;
_min_right=min_right;
- int *tmp;
+ mcIdType *tmp;
tmp=0;
if(!new_elems_left.empty())
tmp=&(new_elems_left[0]);
- _left=new BBTreeDst(bbs, tmp, level+1, (int)new_elems_left.size());
+ _left=new BBTreeDst(bbs, tmp, level+1, (mcIdType)new_elems_left.size());
tmp=0;
if(!new_elems_right.empty())
tmp=&(new_elems_right[0]);
- _right=new BBTreeDst(bbs, tmp, level+1, (int)new_elems_right.size());
+ _right=new BBTreeDst(bbs, tmp, level+1, (mcIdType)new_elems_right.size());
}
~BBTreeDst()
delete [] _terminal;
}
- void getElemsWhoseMinDistanceToPtSmallerThan(const double *pt, double minOfMaxDstsSq, std::vector<int>& elems) const
+ void getElemsWhoseMinDistanceToPtSmallerThan(const double *pt, double minOfMaxDstsSq, std::vector<mcIdType>& elems) const
{
if(_terminal)
{
- for(int i=0; i<_nbelems; i++)
+ for(mcIdType i=0; i<_nbelems; i++)
{
if(GetMinDistanceFromBBoxToPt(_bb+_elems[i]*2*dim,pt)<minOfMaxDstsSq)
elems.push_back(_elems[i]);
{
if(GetMinDistanceFromBBoxToPt(_terminal,pt)>minOfMaxDstsSq)//min it is not a bug
return ;
- for(int i=0; i<_nbelems; i++)
+ for(mcIdType i=0; i<_nbelems; i++)
{
minOfMaxDstsSq=std::min(minOfMaxDstsSq,GetMaxDistanceFromBBoxToPt(_bb+_elems[i]*2*dim,pt));
}
_terminal[2*j]=std::numeric_limits<double>::max();
_terminal[2*j+1]=-std::numeric_limits<double>::max();
}
- for(int i=0;i<_nbelems;i++)
+ for(mcIdType i=0;i<_nbelems;i++)
{
for(int j=0;j<dim;j++)
{
new_elems_right.reserve(nbelems/2+1);
double max_left = -std::numeric_limits<double>::max();
double min_right= std::numeric_limits<double>::max();
- for(int i=0;i<nbelems;i++)
+ for(ConnType i=0;i<nbelems;i++)
{
- int elem;
+ ConnType elem;
if(elems!=0)
elem= elems[i];
else
tmp=0;
if(!new_elems_left.empty())
tmp=&(new_elems_left[0]);
- _left=new BBTreePts(pts, tmp, level+1, (int)new_elems_left.size(),_epsilon);
+ _left=new BBTreePts(pts, tmp, level+1, (ConnType)new_elems_left.size(),_epsilon);
tmp=0;
if(!new_elems_right.empty())
tmp=&(new_elems_right[0]);
- _right=new BBTreePts(pts, tmp, level+1, (int)new_elems_right.size(),_epsilon);
+ _right=new BBTreePts(pts, tmp, level+1, (ConnType)new_elems_right.size(),_epsilon);
}
return _left->getElementsAroundPoint2(xx,threshold,elem);
if(xx[_level%dim]-s>_max_left)
return _right->getElementsAroundPoint2(xx,threshold,elem);
- int eleml,elemr;
+ ConnType eleml,elemr;
double retl=_left->getElementsAroundPoint2(xx,threshold,eleml);
double retr=_right->getElementsAroundPoint2(xx,threshold,elemr);
if(retl<retr)
_right->getElementsAroundPoint(xx,elems);
}
- int size() const
+ ConnType size() const
{
if(_terminal)
return _nbelems;
/*!
* Equivalent to getNumberOfSons except that this method deals with dynamic type.
*/
- unsigned CellModel::getNumberOfSons2(const int *conn, int lgth) const
+ unsigned CellModel::getNumberOfSons2(const mcIdType *conn, int lgth) const
{
if(!isDynamic())
return getNumberOfSons();
return std::count(conn,conn+lgth,-1)+1;
}
- unsigned CellModel::getNumberOfEdgesIn3D(const int *conn, int lgth) const
+ unsigned CellModel::getNumberOfEdgesIn3D(const mcIdType *conn, int lgth) const
{
if(!isDynamic())
return _nb_of_little_sons;
/*!
* \b WARNING this method do not manage correctly types that return true at the call of isDynamic. Use fillSonCellNodalConnectivity2 instead.
*/
- unsigned CellModel::fillSonCellNodalConnectivity(int sonId, const int *nodalConn, int *sonNodalConn) const
+ unsigned CellModel::fillSonCellNodalConnectivity(int sonId, const mcIdType *nodalConn, mcIdType *sonNodalConn) const
{
unsigned nbOfTurnLoop=_nb_of_sons_con[sonId];
const unsigned *sonConn=_sons_con[sonId];
return nbOfTurnLoop;
}
- unsigned CellModel::fillSonCellNodalConnectivity2(int sonId, const int *nodalConn, int lgth, int *sonNodalConn, NormalizedCellType& typeOfSon) const
+ unsigned CellModel::fillSonCellNodalConnectivity2(int sonId, const mcIdType *nodalConn, int lgth, mcIdType *sonNodalConn, NormalizedCellType& typeOfSon) const
{
typeOfSon=getSonType2(sonId);
if(!isDynamic())
}
else if(_dim==3)
{//polyedron
- const int *where=nodalConn;
+ const mcIdType *where=nodalConn;
for(int i=0;i<sonId;i++)
{
where=std::find(where,nodalConn+lgth,-1);
where++;
}
- const int *where2=std::find(where,nodalConn+lgth,-1);
+ const mcIdType *where2=std::find(where,nodalConn+lgth,-1);
std::copy(where,where2,sonNodalConn);
return where2-where;
}
/*!
* Equivalent to CellModel::fillSonCellNodalConnectivity2 except for HEXA8 where the order of sub faces is not has MED file numbering for transformation HEXA8->HEXA27
*/
- unsigned CellModel::fillSonCellNodalConnectivity4(int sonId, const int *nodalConn, int lgth, int *sonNodalConn, NormalizedCellType& typeOfSon) const
+ unsigned CellModel::fillSonCellNodalConnectivity4(int sonId, const mcIdType *nodalConn, int lgth, mcIdType *sonNodalConn, NormalizedCellType& typeOfSon) const
{
if(_type==NORM_HEXA8)
{
return fillSonCellNodalConnectivity2(sonId,nodalConn,lgth,sonNodalConn,typeOfSon);
}
- unsigned CellModel::fillSonEdgesNodalConnectivity3D(int sonId, const int *nodalConn, int lgth, int *sonNodalConn, NormalizedCellType& typeOfSon) const
+ unsigned CellModel::fillSonEdgesNodalConnectivity3D(int sonId, const mcIdType *nodalConn, int lgth, mcIdType *sonNodalConn, NormalizedCellType& typeOfSon) const
{
if(!isDynamic())
{
/*!
* \sa getNumberOfMicroEdges
*/
- unsigned CellModel::fillMicroEdgeNodalConnectivity(int sonId, const int *nodalConn, int *sonNodalConn, NormalizedCellType& typeOfSon) const
+ unsigned CellModel::fillMicroEdgeNodalConnectivity(int sonId, const mcIdType *nodalConn, mcIdType *sonNodalConn, NormalizedCellType& typeOfSon) const
{
if(isQuadratic())
{
}
}
- void CellModel::changeOrientationOf2D(int *nodalConn, unsigned int sz) const
+ void CellModel::changeOrientationOf2D(mcIdType *nodalConn, unsigned int sz) const
{
if(sz<1)
return ;
if(!isQuadratic())
{
- std::vector<int> tmp(sz-1);
+ std::vector<mcIdType> tmp(sz-1);
std::copy(nodalConn+1,nodalConn+sz,tmp.rbegin());
std::copy(tmp.begin(),tmp.end(),nodalConn+1);
}
else
{
unsigned int sz2(sz/2);
- std::vector<int> tmp0(sz2-1),tmp1(sz2);
+ std::vector<mcIdType> tmp0(sz2-1),tmp1(sz2);
std::copy(nodalConn+1,nodalConn+sz2,tmp0.rbegin());
std::copy(nodalConn+sz2,nodalConn+sz,tmp1.rbegin());
std::copy(tmp0.begin(),tmp0.end(),nodalConn+1);
}
}
- void CellModel::changeOrientationOf1D(int *nodalConn, unsigned int sz) const
+ void CellModel::changeOrientationOf1D(mcIdType *nodalConn, unsigned int sz) const
{
if(!isDynamic())
{
}
else
{
- std::vector<int> tmp(sz-1);
+ std::vector<mcIdType> tmp(sz-1);
std::copy(nodalConn+1,nodalConn+sz,tmp.rbegin());
std::copy(tmp.begin(),tmp.end(),nodalConn+1);
}
*/
//================================================================================
- unsigned CellModel::getNumberOfNodesConstituentTheSon2(unsigned sonId, const int *nodalConn, int lgth) const
+ unsigned CellModel::getNumberOfNodesConstituentTheSon2(unsigned sonId, const mcIdType *nodalConn, int lgth) const
{
if(!isDynamic())
return getNumberOfNodesConstituentTheSon(sonId);
}
else if(_dim==3)
{//polyedron
- const int *where=nodalConn;
+ const mcIdType *where=nodalConn;
for(unsigned int i=0;i<sonId;i++)
{
where=std::find(where,nodalConn+lgth,-1);
where++;
}
- const int *where2=std::find(where,nodalConn+lgth,-1);
+ const mcIdType *where2=std::find(where,nodalConn+lgth,-1);
return where2-where;
}
else
* If not an exception will be thrown.
* @return True if two cells have same orientation, false if not.
*/
- bool CellModel::getOrientationStatus(unsigned lgth, const int *conn1, const int *conn2) const
+ bool CellModel::getOrientationStatus(unsigned lgth, const mcIdType *conn1, const mcIdType *conn2) const
{
if(_dim!=1 && _dim!=2)
throw INTERP_KERNEL::Exception("CellModel::getOrientationStatus : invalid dimension ! Must be 1 or 2 !");
if(!_quadratic)
{
- std::vector<int> tmp(2*lgth);
- std::vector<int>::iterator it=std::copy(conn1,conn1+lgth,tmp.begin());
+ std::vector<mcIdType> tmp(2*lgth);
+ std::vector<mcIdType>::iterator it=std::copy(conn1,conn1+lgth,tmp.begin());
std::copy(conn1,conn1+lgth,it);
it=std::search(tmp.begin(),tmp.end(),conn2,conn2+lgth);
if(it==tmp.begin())
return true;
if(it!=tmp.end())
return _dim!=1;
- std::vector<int>::reverse_iterator it2=std::search(tmp.rbegin(),tmp.rend(),conn2,conn2+lgth);
+ std::vector<mcIdType>::reverse_iterator it2=std::search(tmp.rbegin(),tmp.rend(),conn2,conn2+lgth);
if(it2!=tmp.rend())
return false;
throw INTERP_KERNEL::Exception("CellModel::getOrientationStatus : Request of orientation status of non equal connectively cells !");
{
if(_dim!=1)
{
- std::vector<int> tmp(lgth);
- std::vector<int>::iterator it=std::copy(conn1,conn1+lgth/2,tmp.begin());
+ std::vector<mcIdType> tmp(lgth);
+ std::vector<mcIdType>::iterator it=std::copy(conn1,conn1+lgth/2,tmp.begin());
std::copy(conn1,conn1+lgth/2,it);
it=std::search(tmp.begin(),tmp.end(),conn2,conn2+lgth/2);
- int d=std::distance(tmp.begin(),it);
+ std::size_t d=std::distance(tmp.begin(),it);
if(it==tmp.end())
return false;
it=std::copy(conn1+lgth/2,conn1+lgth,tmp.begin());
it=std::search(tmp.begin(),tmp.end(),conn2,conn2+lgth);
if(it==tmp.end())
return false;
- int d2=std::distance(tmp.begin(),it);
+ std::size_t d2=std::distance(tmp.begin(),it);
return d==d2;
}
else
{
int p=(lgth+1)/2;
- std::vector<int> tmp(2*p);
- std::vector<int>::iterator it=std::copy(conn1,conn1+p,tmp.begin());
+ std::vector<mcIdType> tmp(2*p);
+ std::vector<mcIdType>::iterator it=std::copy(conn1,conn1+p,tmp.begin());
std::copy(conn1,conn1+p,it);
it=std::search(tmp.begin(),tmp.end(),conn2,conn2+p);
- int d=std::distance(tmp.begin(),it);
+ std::size_t d=std::distance(tmp.begin(),it);
if(it==tmp.end())
return false;
tmp.resize(2*p-2);
it=std::search(tmp.begin(),tmp.end(),conn2+p,conn2+lgth);
if(it==tmp.end())
return false;
- int d2=std::distance(tmp.begin(),it);
+ std::size_t d2=std::distance(tmp.begin(),it);
return d==d2;
}
}
#include "INTERPKERNELDefines.hxx"
#include "NormalizedUnstructuredMesh.hxx"
+#include "MCIdType.hxx"
#include <map>
//! sonId is in C format.
INTERPKERNEL_EXPORT const unsigned *getNodesConstituentTheSon(unsigned sonId) const { return _sons_con[sonId]; }
INTERPKERNEL_EXPORT const unsigned *getNodesConstituentTheLittleSon(unsigned littleSonId) const { return _little_sons_con[littleSonId]; }
- INTERPKERNEL_EXPORT bool getOrientationStatus(unsigned lgth, const int *conn1, const int *conn2) const;
+ INTERPKERNEL_EXPORT bool getOrientationStatus(unsigned lgth, const mcIdType *conn1, const mcIdType *conn2) const;
INTERPKERNEL_EXPORT unsigned getNumberOfNodes() const { return _nb_of_pts; }
INTERPKERNEL_EXPORT unsigned getNumberOfSons() const { return _nb_of_sons; }
- INTERPKERNEL_EXPORT unsigned getNumberOfSons2(const int *conn, int lgth) const;
- INTERPKERNEL_EXPORT unsigned getNumberOfEdgesIn3D(const int *conn, int lgth) const;
+ INTERPKERNEL_EXPORT unsigned getNumberOfSons2(const mcIdType *conn, int lgth) const;
+ INTERPKERNEL_EXPORT unsigned getNumberOfEdgesIn3D(const mcIdType *conn, int lgth) const;
INTERPKERNEL_EXPORT unsigned getNumberOfMicroEdges() const;
INTERPKERNEL_EXPORT unsigned getNumberOfNodesConstituentTheSon(unsigned sonId) const { return _nb_of_sons_con[sonId]; }
- INTERPKERNEL_EXPORT unsigned getNumberOfNodesConstituentTheSon2(unsigned sonId, const int *nodalConn, int lgth) const;
+ INTERPKERNEL_EXPORT unsigned getNumberOfNodesConstituentTheSon2(unsigned sonId, const mcIdType *nodalConn, int lgth) const;
INTERPKERNEL_EXPORT NormalizedCellType getExtrudedType() const { return _extruded_type; }
INTERPKERNEL_EXPORT NormalizedCellType getCorrespondingPolyType() const;
INTERPKERNEL_EXPORT NormalizedCellType getReverseExtrudedType() const { return _reverse_extruded_type; }
INTERPKERNEL_EXPORT NormalizedCellType getQuadraticType2() const { return _quadratic_type2; }
INTERPKERNEL_EXPORT NormalizedCellType getSonType(unsigned sonId) const { return _sons_type[sonId]; }
INTERPKERNEL_EXPORT NormalizedCellType getSonType2(unsigned sonId) const;
- INTERPKERNEL_EXPORT unsigned fillSonCellNodalConnectivity(int sonId, const int *nodalConn, int *sonNodalConn) const;
- INTERPKERNEL_EXPORT unsigned fillSonCellNodalConnectivity2(int sonId, const int *nodalConn, int lgth, int *sonNodalConn, NormalizedCellType& typeOfSon) const;
- INTERPKERNEL_EXPORT unsigned fillSonCellNodalConnectivity4(int sonId, const int *nodalConn, int lgth, int *sonNodalConn, NormalizedCellType& typeOfSon) const;
- INTERPKERNEL_EXPORT unsigned fillSonEdgesNodalConnectivity3D(int sonId, const int *nodalConn, int lgth, int *sonNodalConn, NormalizedCellType& typeOfSon) const;
- INTERPKERNEL_EXPORT unsigned fillMicroEdgeNodalConnectivity(int sonId, const int *nodalConn, int *sonNodalConn, NormalizedCellType& typeOfSon) const;
- INTERPKERNEL_EXPORT void changeOrientationOf2D(int *nodalConn, unsigned int sz) const;
- INTERPKERNEL_EXPORT void changeOrientationOf1D(int *nodalConn, unsigned int sz) const;
+ INTERPKERNEL_EXPORT unsigned fillSonCellNodalConnectivity(int sonId, const mcIdType *nodalConn, mcIdType *sonNodalConn) const;
+ INTERPKERNEL_EXPORT unsigned fillSonCellNodalConnectivity2(int sonId, const mcIdType *nodalConn, int lgth, mcIdType *sonNodalConn, NormalizedCellType& typeOfSon) const;
+ INTERPKERNEL_EXPORT unsigned fillSonCellNodalConnectivity4(int sonId, const mcIdType *nodalConn, int lgth, mcIdType *sonNodalConn, NormalizedCellType& typeOfSon) const;
+ INTERPKERNEL_EXPORT unsigned fillSonEdgesNodalConnectivity3D(int sonId, const mcIdType *nodalConn, int lgth, mcIdType *sonNodalConn, NormalizedCellType& typeOfSon) const;
+ INTERPKERNEL_EXPORT unsigned fillMicroEdgeNodalConnectivity(int sonId, const mcIdType *nodalConn, mcIdType *sonNodalConn, NormalizedCellType& typeOfSon) const;
+ INTERPKERNEL_EXPORT void changeOrientationOf2D(mcIdType *nodalConn, unsigned int sz) const;
+ INTERPKERNEL_EXPORT void changeOrientationOf1D(mcIdType *nodalConn, unsigned int sz) const;
INTERPKERNEL_EXPORT DiameterCalculator *buildInstanceOfDiameterCalulator(int spaceDim) const;
INTERPKERNEL_EXPORT OrientationInverter *buildOrientationInverter() const;
private:
}
template<class Evaluator>
-void ComputeForListOfCellIdsUMeshFrmt(const int *bgIds, const int *endIds, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr)
+void ComputeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr)
{
Evaluator evtor;
NormalizedCellType ct(Evaluator::TYPE);
int cti((int) ct);
- for(const int *it=bgIds;it!=endIds;it++)
+ for(const mcIdType *it=bgIds;it!=endIds;it++)
{
- int offset(indPtr[*it]);
+ mcIdType offset(indPtr[*it]);
if(connPtr[offset]==cti)
resPtr[*it]=evtor.ComputeForOneCellInternal(connPtr+offset+1,connPtr+indPtr[(*it)+1],coordsPtr);
else
}
template<class Evaluator>
-void ComputeForRangeOfCellIdsUMeshFrmt(int bgId, int endId, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr)
+void ComputeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr)
{
Evaluator evtor;
NormalizedCellType ct(Evaluator::TYPE);
int cti((int) ct);
- for(int it=bgId;it<endId;it++)
+ for(mcIdType it=bgId;it<endId;it++)
{
- int offset(indPtr[it]);
+ mcIdType offset(indPtr[it]);
if(connPtr[offset]==cti)
resPtr[it]=evtor.ComputeForOneCellInternal(connPtr+offset+1,connPtr+indPtr[it+1],coordsPtr);
else
}
template<class Evaluator>
-void ComputeFor1SGTUMeshFrmt(int nbOfCells, const int *connPtr, const double *coordsPtr, double *resPtr)
+void ComputeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr)
{
Evaluator evtor;
NormalizedCellType ct(Evaluator::TYPE);
const CellModel& cm(CellModel::GetCellModel(ct));
unsigned nbNodes(cm.getNumberOfNodes());
- const int *ptr(connPtr);
- for(int i=0;i<nbOfCells;i++,ptr+=nbNodes,resPtr++)
+ const mcIdType *ptr(connPtr);
+ for(mcIdType i=0;i<nbOfCells;i++,ptr+=nbNodes,resPtr++)
*resPtr=evtor.ComputeForOneCellInternal(ptr,ptr+nbNodes,coordsPtr);
}
//=================================================================
-double DiameterCalulatorTRI3S2::ComputeForOneCellInternal(const int *bg, const int *endd, const double *coordsPtr)
+double DiameterCalulatorTRI3S2::ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr)
{
if(std::distance(bg,endd)==3)
{
throw Exception("DiameterCalulatorTRI3S2::ComputeForOneCellInternal : input connectivity must be of size 3 !");
}
-void DiameterCalulatorTRI3S2::computeForListOfCellIdsUMeshFrmt(const int *bgIds, const int *endIds, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorTRI3S2::computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeForListOfCellIdsUMeshFrmt<DiameterCalulatorTRI3S2>(bgIds,endIds,indPtr,connPtr,coordsPtr,resPtr);
}
-void DiameterCalulatorTRI3S2::computeForRangeOfCellIdsUMeshFrmt(int bgId, int endId, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorTRI3S2::computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeForRangeOfCellIdsUMeshFrmt<DiameterCalulatorTRI3S2>(bgId,endId,indPtr,connPtr,coordsPtr,resPtr);
}
-void DiameterCalulatorTRI3S2::computeFor1SGTUMeshFrmt(int nbOfCells, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorTRI3S2::computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeFor1SGTUMeshFrmt<DiameterCalulatorTRI3S2>(nbOfCells,connPtr,coordsPtr,resPtr);
}
//=================================================================
-double DiameterCalulatorTRI3S3::ComputeForOneCellInternal(const int *bg, const int *endd, const double *coordsPtr)
+double DiameterCalulatorTRI3S3::ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr)
{
if(std::distance(bg,endd)==3)
{
throw Exception("DiameterCalulatorTRI3S2::ComputeForOneCellInternal : input connectivity must be of size 3 !");
}
-void DiameterCalulatorTRI3S3::computeForListOfCellIdsUMeshFrmt(const int *bgIds, const int *endIds, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorTRI3S3::computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeForListOfCellIdsUMeshFrmt<DiameterCalulatorTRI3S3>(bgIds,endIds,indPtr,connPtr,coordsPtr,resPtr);
}
-void DiameterCalulatorTRI3S3::computeForRangeOfCellIdsUMeshFrmt(int bgId, int endId, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorTRI3S3::computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeForRangeOfCellIdsUMeshFrmt<DiameterCalulatorTRI3S3>(bgId,endId,indPtr,connPtr,coordsPtr,resPtr);
}
-void DiameterCalulatorTRI3S3::computeFor1SGTUMeshFrmt(int nbOfCells, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorTRI3S3::computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeFor1SGTUMeshFrmt<DiameterCalulatorTRI3S3>(nbOfCells,connPtr,coordsPtr,resPtr);
}
//=================================================================
-double DiameterCalulatorTRI6S2::ComputeForOneCellInternal(const int *bg, const int *endd, const double *coordsPtr)
+double DiameterCalulatorTRI6S2::ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr)
{
if(std::distance(bg,endd)==6)
return DiameterCalulatorTRI3S2::ComputeForOneCellInternal(bg,bg+3,coordsPtr);
throw Exception("DiameterCalulatorTRI6S2::ComputeForOneCellInternal : input connectivity must be of size 6 !");
}
-void DiameterCalulatorTRI6S2::computeForListOfCellIdsUMeshFrmt(const int *bgIds, const int *endIds, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorTRI6S2::computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeForListOfCellIdsUMeshFrmt<DiameterCalulatorTRI6S2>(bgIds,endIds,indPtr,connPtr,coordsPtr,resPtr);
}
-void DiameterCalulatorTRI6S2::computeForRangeOfCellIdsUMeshFrmt(int bgId, int endId, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorTRI6S2::computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeForRangeOfCellIdsUMeshFrmt<DiameterCalulatorTRI6S2>(bgId,endId,indPtr,connPtr,coordsPtr,resPtr);
}
-void DiameterCalulatorTRI6S2::computeFor1SGTUMeshFrmt(int nbOfCells, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorTRI6S2::computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeFor1SGTUMeshFrmt<DiameterCalulatorTRI6S2>(nbOfCells,connPtr,coordsPtr,resPtr);
}
//=================================================================
-double DiameterCalulatorTRI6S3::ComputeForOneCellInternal(const int *bg, const int *endd, const double *coordsPtr)
+double DiameterCalulatorTRI6S3::ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr)
{
if(std::distance(bg,endd)==6)
return DiameterCalulatorTRI3S3::ComputeForOneCellInternal(bg,bg+3,coordsPtr);
throw Exception("DiameterCalulatorTRI6S3::ComputeForOneCellInternal : input connectivity must be of size 6 !");
}
-void DiameterCalulatorTRI6S3::computeForListOfCellIdsUMeshFrmt(const int *bgIds, const int *endIds, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorTRI6S3::computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeForListOfCellIdsUMeshFrmt<DiameterCalulatorTRI6S3>(bgIds,endIds,indPtr,connPtr,coordsPtr,resPtr);
}
-void DiameterCalulatorTRI6S3::computeForRangeOfCellIdsUMeshFrmt(int bgId, int endId, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorTRI6S3::computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeForRangeOfCellIdsUMeshFrmt<DiameterCalulatorTRI6S3>(bgId,endId,indPtr,connPtr,coordsPtr,resPtr);
}
-void DiameterCalulatorTRI6S3::computeFor1SGTUMeshFrmt(int nbOfCells, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorTRI6S3::computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeFor1SGTUMeshFrmt<DiameterCalulatorTRI6S3>(nbOfCells,connPtr,coordsPtr,resPtr);
}
//=================================================================
-double DiameterCalulatorTRI7S2::ComputeForOneCellInternal(const int *bg, const int *endd, const double *coordsPtr)
+double DiameterCalulatorTRI7S2::ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr)
{
if(std::distance(bg,endd)==7)
return DiameterCalulatorTRI3S2::ComputeForOneCellInternal(bg,bg+3,coordsPtr);
throw Exception("DiameterCalulatorTRI7S2::ComputeForOneCellInternal : input connectivity must be of size 7 !");
}
-void DiameterCalulatorTRI7S2::computeForListOfCellIdsUMeshFrmt(const int *bgIds, const int *endIds, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorTRI7S2::computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeForListOfCellIdsUMeshFrmt<DiameterCalulatorTRI7S2>(bgIds,endIds,indPtr,connPtr,coordsPtr,resPtr);
}
-void DiameterCalulatorTRI7S2::computeForRangeOfCellIdsUMeshFrmt(int bgId, int endId, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorTRI7S2::computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeForRangeOfCellIdsUMeshFrmt<DiameterCalulatorTRI7S2>(bgId,endId,indPtr,connPtr,coordsPtr,resPtr);
}
-void DiameterCalulatorTRI7S2::computeFor1SGTUMeshFrmt(int nbOfCells, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorTRI7S2::computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeFor1SGTUMeshFrmt<DiameterCalulatorTRI7S2>(nbOfCells,connPtr,coordsPtr,resPtr);
}
//=================================================================
-double DiameterCalulatorTRI7S3::ComputeForOneCellInternal(const int *bg, const int *endd, const double *coordsPtr)
+double DiameterCalulatorTRI7S3::ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr)
{
if(std::distance(bg,endd)==7)
return DiameterCalulatorTRI3S3::ComputeForOneCellInternal(bg,bg+3,coordsPtr);
throw Exception("DiameterCalulatorTRI7S3::ComputeForOneCellInternal : input connectivity must be of size 7 !");
}
-void DiameterCalulatorTRI7S3::computeForListOfCellIdsUMeshFrmt(const int *bgIds, const int *endIds, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorTRI7S3::computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeForListOfCellIdsUMeshFrmt<DiameterCalulatorTRI7S3>(bgIds,endIds,indPtr,connPtr,coordsPtr,resPtr);
}
-void DiameterCalulatorTRI7S3::computeForRangeOfCellIdsUMeshFrmt(int bgId, int endId, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorTRI7S3::computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeForRangeOfCellIdsUMeshFrmt<DiameterCalulatorTRI7S3>(bgId,endId,indPtr,connPtr,coordsPtr,resPtr);
}
-void DiameterCalulatorTRI7S3::computeFor1SGTUMeshFrmt(int nbOfCells, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorTRI7S3::computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeFor1SGTUMeshFrmt<DiameterCalulatorTRI7S3>(nbOfCells,connPtr,coordsPtr,resPtr);
}
//=================================================================
-double DiameterCalulatorQUAD4S2::ComputeForOneCellInternal(const int *bg, const int *endd, const double *coordsPtr)
+double DiameterCalulatorQUAD4S2::ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr)
{
if(std::distance(bg,endd)==4)
{
throw Exception("DiameterCalulatorQUAD4S2::ComputeForOneCellInternal : input connectivity must be of size 4 !");
}
-void DiameterCalulatorQUAD4S2::computeForListOfCellIdsUMeshFrmt(const int *bgIds, const int *endIds, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorQUAD4S2::computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeForListOfCellIdsUMeshFrmt<DiameterCalulatorQUAD4S2>(bgIds,endIds,indPtr,connPtr,coordsPtr,resPtr);
}
-void DiameterCalulatorQUAD4S2::computeForRangeOfCellIdsUMeshFrmt(int bgId, int endId, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorQUAD4S2::computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeForRangeOfCellIdsUMeshFrmt<DiameterCalulatorQUAD4S2>(bgId,endId,indPtr,connPtr,coordsPtr,resPtr);
}
-void DiameterCalulatorQUAD4S2::computeFor1SGTUMeshFrmt(int nbOfCells, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorQUAD4S2::computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeFor1SGTUMeshFrmt<DiameterCalulatorQUAD4S2>(nbOfCells,connPtr,coordsPtr,resPtr);
}
//=================================================================
-double DiameterCalulatorQUAD4S3::ComputeForOneCellInternal(const int *bg, const int *endd, const double *coordsPtr)
+double DiameterCalulatorQUAD4S3::ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr)
{
if(std::distance(bg,endd)==4)
{
throw Exception("DiameterCalulatorQUAD4S3::ComputeForOneCellInternal : input connectivity must be of size 4 !");
}
-void DiameterCalulatorQUAD4S3::computeForListOfCellIdsUMeshFrmt(const int *bgIds, const int *endIds, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorQUAD4S3::computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeForListOfCellIdsUMeshFrmt<DiameterCalulatorQUAD4S3>(bgIds,endIds,indPtr,connPtr,coordsPtr,resPtr);
}
-void DiameterCalulatorQUAD4S3::computeForRangeOfCellIdsUMeshFrmt(int bgId, int endId, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorQUAD4S3::computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeForRangeOfCellIdsUMeshFrmt<DiameterCalulatorQUAD4S3>(bgId,endId,indPtr,connPtr,coordsPtr,resPtr);
}
-void DiameterCalulatorQUAD4S3::computeFor1SGTUMeshFrmt(int nbOfCells, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorQUAD4S3::computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeFor1SGTUMeshFrmt<DiameterCalulatorQUAD4S3>(nbOfCells,connPtr,coordsPtr,resPtr);
}
//=================================================================
-double DiameterCalulatorQUAD8S2::ComputeForOneCellInternal(const int *bg, const int *endd, const double *coordsPtr)
+double DiameterCalulatorQUAD8S2::ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr)
{
if(std::distance(bg,endd)==8)
return DiameterCalulatorQUAD4S2::ComputeForOneCellInternal(bg,bg+4,coordsPtr);
throw Exception("DiameterCalulatorQUAD8S2::ComputeForOneCellInternal : input connectivity must be of size 8 !");
}
-void DiameterCalulatorQUAD8S2::computeForListOfCellIdsUMeshFrmt(const int *bgIds, const int *endIds, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorQUAD8S2::computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeForListOfCellIdsUMeshFrmt<DiameterCalulatorQUAD8S2>(bgIds,endIds,indPtr,connPtr,coordsPtr,resPtr);
}
-void DiameterCalulatorQUAD8S2::computeForRangeOfCellIdsUMeshFrmt(int bgId, int endId, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorQUAD8S2::computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeForRangeOfCellIdsUMeshFrmt<DiameterCalulatorQUAD8S2>(bgId,endId,indPtr,connPtr,coordsPtr,resPtr);
}
-void DiameterCalulatorQUAD8S2::computeFor1SGTUMeshFrmt(int nbOfCells, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorQUAD8S2::computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeFor1SGTUMeshFrmt<DiameterCalulatorQUAD8S2>(nbOfCells,connPtr,coordsPtr,resPtr);
}
//=================================================================
-double DiameterCalulatorQUAD8S3::ComputeForOneCellInternal(const int *bg, const int *endd, const double *coordsPtr)
+double DiameterCalulatorQUAD8S3::ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr)
{
if(std::distance(bg,endd)==8)
return DiameterCalulatorQUAD4S3::ComputeForOneCellInternal(bg,bg+4,coordsPtr);
throw Exception("DiameterCalulatorQUAD8S3::ComputeForOneCellInternal : input connectivity must be of size 8 !");
}
-void DiameterCalulatorQUAD8S3::computeForListOfCellIdsUMeshFrmt(const int *bgIds, const int *endIds, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorQUAD8S3::computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeForListOfCellIdsUMeshFrmt<DiameterCalulatorQUAD8S3>(bgIds,endIds,indPtr,connPtr,coordsPtr,resPtr);
}
-void DiameterCalulatorQUAD8S3::computeForRangeOfCellIdsUMeshFrmt(int bgId, int endId, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorQUAD8S3::computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeForRangeOfCellIdsUMeshFrmt<DiameterCalulatorQUAD8S3>(bgId,endId,indPtr,connPtr,coordsPtr,resPtr);
}
-void DiameterCalulatorQUAD8S3::computeFor1SGTUMeshFrmt(int nbOfCells, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorQUAD8S3::computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeFor1SGTUMeshFrmt<DiameterCalulatorQUAD8S3>(nbOfCells,connPtr,coordsPtr,resPtr);
}
//=================================================================
-double DiameterCalulatorQUAD9S2::ComputeForOneCellInternal(const int *bg, const int *endd, const double *coordsPtr)
+double DiameterCalulatorQUAD9S2::ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr)
{
if(std::distance(bg,endd)==9)
return DiameterCalulatorQUAD4S2::ComputeForOneCellInternal(bg,bg+4,coordsPtr);
throw Exception("DiameterCalulatorQUAD9S2::ComputeForOneCellInternal : input connectivity must be of size 9 !");
}
-void DiameterCalulatorQUAD9S2::computeForListOfCellIdsUMeshFrmt(const int *bgIds, const int *endIds, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorQUAD9S2::computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeForListOfCellIdsUMeshFrmt<DiameterCalulatorQUAD9S2>(bgIds,endIds,indPtr,connPtr,coordsPtr,resPtr);
}
-void DiameterCalulatorQUAD9S2::computeForRangeOfCellIdsUMeshFrmt(int bgId, int endId, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorQUAD9S2::computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeForRangeOfCellIdsUMeshFrmt<DiameterCalulatorQUAD9S2>(bgId,endId,indPtr,connPtr,coordsPtr,resPtr);
}
-void DiameterCalulatorQUAD9S2::computeFor1SGTUMeshFrmt(int nbOfCells, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorQUAD9S2::computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeFor1SGTUMeshFrmt<DiameterCalulatorQUAD9S2>(nbOfCells,connPtr,coordsPtr,resPtr);
}
//=================================================================
-double DiameterCalulatorQUAD9S3::ComputeForOneCellInternal(const int *bg, const int *endd, const double *coordsPtr)
+double DiameterCalulatorQUAD9S3::ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr)
{
if(std::distance(bg,endd)==9)
return DiameterCalulatorQUAD4S3::ComputeForOneCellInternal(bg,bg+4,coordsPtr);
throw Exception("DiameterCalulatorQUAD8S3::ComputeForOneCellInternal : input connectivity must be of size 9 !");
}
-void DiameterCalulatorQUAD9S3::computeForListOfCellIdsUMeshFrmt(const int *bgIds, const int *endIds, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorQUAD9S3::computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeForListOfCellIdsUMeshFrmt<DiameterCalulatorQUAD9S3>(bgIds,endIds,indPtr,connPtr,coordsPtr,resPtr);
}
-void DiameterCalulatorQUAD9S3::computeForRangeOfCellIdsUMeshFrmt(int bgId, int endId, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorQUAD9S3::computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeForRangeOfCellIdsUMeshFrmt<DiameterCalulatorQUAD9S3>(bgId,endId,indPtr,connPtr,coordsPtr,resPtr);
}
-void DiameterCalulatorQUAD9S3::computeFor1SGTUMeshFrmt(int nbOfCells, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorQUAD9S3::computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeFor1SGTUMeshFrmt<DiameterCalulatorQUAD9S3>(nbOfCells,connPtr,coordsPtr,resPtr);
}
//=================================================================
-double DiameterCalulatorTETRA4::ComputeForOneCellInternal(const int *bg, const int *endd, const double *coordsPtr)
+double DiameterCalulatorTETRA4::ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr)
{
if(std::distance(bg,endd)==4)
{
throw Exception("DiameterCalulatorTETRA4::ComputeForOneCellInternal : input connectivity must be of size 4 !");
}
-void DiameterCalulatorTETRA4::computeForListOfCellIdsUMeshFrmt(const int *bgIds, const int *endIds, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorTETRA4::computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeForListOfCellIdsUMeshFrmt<DiameterCalulatorTETRA4>(bgIds,endIds,indPtr,connPtr,coordsPtr,resPtr);
}
-void DiameterCalulatorTETRA4::computeForRangeOfCellIdsUMeshFrmt(int bgId, int endId, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorTETRA4::computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeForRangeOfCellIdsUMeshFrmt<DiameterCalulatorTETRA4>(bgId,endId,indPtr,connPtr,coordsPtr,resPtr);
}
-void DiameterCalulatorTETRA4::computeFor1SGTUMeshFrmt(int nbOfCells, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorTETRA4::computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeFor1SGTUMeshFrmt<DiameterCalulatorTETRA4>(nbOfCells,connPtr,coordsPtr,resPtr);
}
//=================================================================
-double DiameterCalulatorTETRA10::ComputeForOneCellInternal(const int *bg, const int *endd, const double *coordsPtr)
+double DiameterCalulatorTETRA10::ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr)
{
if(std::distance(bg,endd)==10)
return DiameterCalulatorTETRA4::ComputeForOneCellInternal(bg,bg+4,coordsPtr);
throw Exception("DiameterCalulatorTETRA10::ComputeForOneCellInternal : input connectivity must be of size 10 !");
}
-void DiameterCalulatorTETRA10::computeForListOfCellIdsUMeshFrmt(const int *bgIds, const int *endIds, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorTETRA10::computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeForListOfCellIdsUMeshFrmt<DiameterCalulatorTETRA10>(bgIds,endIds,indPtr,connPtr,coordsPtr,resPtr);
}
-void DiameterCalulatorTETRA10::computeForRangeOfCellIdsUMeshFrmt(int bgId, int endId, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorTETRA10::computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeForRangeOfCellIdsUMeshFrmt<DiameterCalulatorTETRA10>(bgId,endId,indPtr,connPtr,coordsPtr,resPtr);
}
-void DiameterCalulatorTETRA10::computeFor1SGTUMeshFrmt(int nbOfCells, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorTETRA10::computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeFor1SGTUMeshFrmt<DiameterCalulatorTETRA10>(nbOfCells,connPtr,coordsPtr,resPtr);
}
//=================================================================
-double DiameterCalulatorHEXA8::ComputeForOneCellInternal(const int *bg, const int *endd, const double *coordsPtr)
+double DiameterCalulatorHEXA8::ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr)
{
if(std::distance(bg,endd)==8)
{
throw Exception("DiameterCalulatorHEXA8::ComputeForOneCellInternal : input connectivity must be of size 8 !");
}
-void DiameterCalulatorHEXA8::computeForListOfCellIdsUMeshFrmt(const int *bgIds, const int *endIds, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorHEXA8::computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeForListOfCellIdsUMeshFrmt<DiameterCalulatorHEXA8>(bgIds,endIds,indPtr,connPtr,coordsPtr,resPtr);
}
-void DiameterCalulatorHEXA8::computeForRangeOfCellIdsUMeshFrmt(int bgId, int endId, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorHEXA8::computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeForRangeOfCellIdsUMeshFrmt<DiameterCalulatorHEXA8>(bgId,endId,indPtr,connPtr,coordsPtr,resPtr);
}
-void DiameterCalulatorHEXA8::computeFor1SGTUMeshFrmt(int nbOfCells, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorHEXA8::computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeFor1SGTUMeshFrmt<DiameterCalulatorHEXA8>(nbOfCells,connPtr,coordsPtr,resPtr);
}
//=================================================================
-double DiameterCalulatorHEXA20::ComputeForOneCellInternal(const int *bg, const int *endd, const double *coordsPtr)
+double DiameterCalulatorHEXA20::ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr)
{
if(std::distance(bg,endd)==20)
return DiameterCalulatorHEXA8::ComputeForOneCellInternal(bg,bg+8,coordsPtr);
throw Exception("DiameterCalulatorHEXA20::ComputeForOneCellInternal : input connectivity must be of size 20 !");
}
-void DiameterCalulatorHEXA20::computeForListOfCellIdsUMeshFrmt(const int *bgIds, const int *endIds, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorHEXA20::computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeForListOfCellIdsUMeshFrmt<DiameterCalulatorHEXA20>(bgIds,endIds,indPtr,connPtr,coordsPtr,resPtr);
}
-void DiameterCalulatorHEXA20::computeForRangeOfCellIdsUMeshFrmt(int bgId, int endId, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorHEXA20::computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeForRangeOfCellIdsUMeshFrmt<DiameterCalulatorHEXA20>(bgId,endId,indPtr,connPtr,coordsPtr,resPtr);
}
-void DiameterCalulatorHEXA20::computeFor1SGTUMeshFrmt(int nbOfCells, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorHEXA20::computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeFor1SGTUMeshFrmt<DiameterCalulatorHEXA20>(nbOfCells,connPtr,coordsPtr,resPtr);
}
//=================================================================
-double DiameterCalulatorHEXA27::ComputeForOneCellInternal(const int *bg, const int *endd, const double *coordsPtr)
+double DiameterCalulatorHEXA27::ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr)
{
if(std::distance(bg,endd)==27)
return DiameterCalulatorHEXA8::ComputeForOneCellInternal(bg,bg+8,coordsPtr);
throw Exception("DiameterCalulatorHEXA27::ComputeForOneCellInternal : input connectivity must be of size 27 !");
}
-void DiameterCalulatorHEXA27::computeForListOfCellIdsUMeshFrmt(const int *bgIds, const int *endIds, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorHEXA27::computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeForListOfCellIdsUMeshFrmt<DiameterCalulatorHEXA27>(bgIds,endIds,indPtr,connPtr,coordsPtr,resPtr);
}
-void DiameterCalulatorHEXA27::computeForRangeOfCellIdsUMeshFrmt(int bgId, int endId, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorHEXA27::computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeForRangeOfCellIdsUMeshFrmt<DiameterCalulatorHEXA27>(bgId,endId,indPtr,connPtr,coordsPtr,resPtr);
}
-void DiameterCalulatorHEXA27::computeFor1SGTUMeshFrmt(int nbOfCells, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorHEXA27::computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeFor1SGTUMeshFrmt<DiameterCalulatorHEXA27>(nbOfCells,connPtr,coordsPtr,resPtr);
}
//=================================================================
-double DiameterCalulatorPENTA6::ComputeForOneCellInternal(const int *bg, const int *endd, const double *coordsPtr)
+double DiameterCalulatorPENTA6::ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr)
{
if(std::distance(bg,endd)==6)
{
throw Exception("DiameterCalulatorPENTA6::ComputeForOneCellInternal : input connectivity must be of size 6 !");
}
-void DiameterCalulatorPENTA6::computeForListOfCellIdsUMeshFrmt(const int *bgIds, const int *endIds, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorPENTA6::computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeForListOfCellIdsUMeshFrmt<DiameterCalulatorPENTA6>(bgIds,endIds,indPtr,connPtr,coordsPtr,resPtr);
}
-void DiameterCalulatorPENTA6::computeForRangeOfCellIdsUMeshFrmt(int bgId, int endId, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorPENTA6::computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeForRangeOfCellIdsUMeshFrmt<DiameterCalulatorPENTA6>(bgId,endId,indPtr,connPtr,coordsPtr,resPtr);
}
-void DiameterCalulatorPENTA6::computeFor1SGTUMeshFrmt(int nbOfCells, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorPENTA6::computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeFor1SGTUMeshFrmt<DiameterCalulatorPENTA6>(nbOfCells,connPtr,coordsPtr,resPtr);
}
//=================================================================
-double DiameterCalulatorPENTA15::ComputeForOneCellInternal(const int *bg, const int *endd, const double *coordsPtr)
+double DiameterCalulatorPENTA15::ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr)
{
if(std::distance(bg,endd)==15)
return DiameterCalulatorPENTA6::ComputeForOneCellInternal(bg,bg+6,coordsPtr);
throw Exception("DiameterCalulatorPENTA15::ComputeForOneCellInternal : input connectivity must be of size 15 !");
}
-void DiameterCalulatorPENTA15::computeForListOfCellIdsUMeshFrmt(const int *bgIds, const int *endIds, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorPENTA15::computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeForListOfCellIdsUMeshFrmt<DiameterCalulatorPENTA15>(bgIds,endIds,indPtr,connPtr,coordsPtr,resPtr);
}
-void DiameterCalulatorPENTA15::computeForRangeOfCellIdsUMeshFrmt(int bgId, int endId, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorPENTA15::computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeForRangeOfCellIdsUMeshFrmt<DiameterCalulatorPENTA15>(bgId,endId,indPtr,connPtr,coordsPtr,resPtr);
}
-void DiameterCalulatorPENTA15::computeFor1SGTUMeshFrmt(int nbOfCells, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorPENTA15::computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeFor1SGTUMeshFrmt<DiameterCalulatorPENTA15>(nbOfCells,connPtr,coordsPtr,resPtr);
}
//=================================================================
-double DiameterCalulatorPYRA5::ComputeForOneCellInternal(const int *bg, const int *endd, const double *coordsPtr)
+double DiameterCalulatorPYRA5::ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr)
{
if(std::distance(bg,endd)==5)
{
throw Exception("DiameterCalulatorPYRA5::ComputeForOneCellInternal : input connectivity must be of size 5 !");
}
-void DiameterCalulatorPYRA5::computeForListOfCellIdsUMeshFrmt(const int *bgIds, const int *endIds, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorPYRA5::computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeForListOfCellIdsUMeshFrmt<DiameterCalulatorPYRA5>(bgIds,endIds,indPtr,connPtr,coordsPtr,resPtr);
}
-void DiameterCalulatorPYRA5::computeForRangeOfCellIdsUMeshFrmt(int bgId, int endId, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorPYRA5::computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeForRangeOfCellIdsUMeshFrmt<DiameterCalulatorPYRA5>(bgId,endId,indPtr,connPtr,coordsPtr,resPtr);
}
-void DiameterCalulatorPYRA5::computeFor1SGTUMeshFrmt(int nbOfCells, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorPYRA5::computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeFor1SGTUMeshFrmt<DiameterCalulatorPYRA5>(nbOfCells,connPtr,coordsPtr,resPtr);
}
//=================================================================
-double DiameterCalulatorPYRA13::ComputeForOneCellInternal(const int *bg, const int *endd, const double *coordsPtr)
+double DiameterCalulatorPYRA13::ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr)
{
if(std::distance(bg,endd)==13)
return DiameterCalulatorPYRA5::ComputeForOneCellInternal(bg,bg+5,coordsPtr);
throw Exception("DiameterCalulatorPYRA13::ComputeForOneCellInternal : input connectivity must be of size 13 !");
}
-void DiameterCalulatorPYRA13::computeForListOfCellIdsUMeshFrmt(const int *bgIds, const int *endIds, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorPYRA13::computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeForListOfCellIdsUMeshFrmt<DiameterCalulatorPYRA13>(bgIds,endIds,indPtr,connPtr,coordsPtr,resPtr);
}
-void DiameterCalulatorPYRA13::computeForRangeOfCellIdsUMeshFrmt(int bgId, int endId, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorPYRA13::computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeForRangeOfCellIdsUMeshFrmt<DiameterCalulatorPYRA13>(bgId,endId,indPtr,connPtr,coordsPtr,resPtr);
}
-void DiameterCalulatorPYRA13::computeFor1SGTUMeshFrmt(int nbOfCells, const int *connPtr, const double *coordsPtr, double *resPtr) const
+void DiameterCalulatorPYRA13::computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const
{
ComputeFor1SGTUMeshFrmt<DiameterCalulatorPYRA13>(nbOfCells,connPtr,coordsPtr,resPtr);
}
#include "INTERPKERNELDefines.hxx"
#include "NormalizedGeometricTypes"
+#include "MCIdType.hxx"
namespace INTERP_KERNEL
{
public:
INTERPKERNEL_EXPORT virtual ~DiameterCalculator() { }
INTERPKERNEL_EXPORT virtual NormalizedCellType getType() const = 0;
- INTERPKERNEL_EXPORT virtual double computeForOneCell(const int *bg, const int *endd, const double *coordsPtr) const = 0;
- INTERPKERNEL_EXPORT virtual void computeForListOfCellIdsUMeshFrmt(const int *bgIds, const int *endIds, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const = 0;
- INTERPKERNEL_EXPORT virtual void computeForRangeOfCellIdsUMeshFrmt(int bgId, int endId, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const = 0;
- INTERPKERNEL_EXPORT virtual void computeFor1SGTUMeshFrmt(int nbOfCells, const int *connPtr, const double *coordsPtr, double *resPtr) const = 0;
+ INTERPKERNEL_EXPORT virtual double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const = 0;
+ INTERPKERNEL_EXPORT virtual void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const = 0;
+ INTERPKERNEL_EXPORT virtual void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const = 0;
+ INTERPKERNEL_EXPORT virtual void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const = 0;
};
class DiameterCalulatorTRI3S2 : public DiameterCalculator
{
public:
NormalizedCellType getType() const { return TYPE; }
- double computeForOneCell(const int *bg, const int *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
- static double ComputeForOneCellInternal(const int *bg, const int *endd, const double *coordsPtr);
- void computeForListOfCellIdsUMeshFrmt(const int *bgIds, const int *endIds, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeForRangeOfCellIdsUMeshFrmt(int bgId, int endId, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeFor1SGTUMeshFrmt(int nbOfCells, const int *connPtr, const double *coordsPtr, double *resPtr) const;
+ double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
+ static double ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr);
+ void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
public:
static NormalizedCellType TYPE;
};
{
public:
NormalizedCellType getType() const { return TYPE; }
- double computeForOneCell(const int *bg, const int *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
- static double ComputeForOneCellInternal(const int *bg, const int *endd, const double *coordsPtr);
- void computeForListOfCellIdsUMeshFrmt(const int *bgIds, const int *endIds, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeForRangeOfCellIdsUMeshFrmt(int bgId, int endId, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeFor1SGTUMeshFrmt(int nbOfCells, const int *connPtr, const double *coordsPtr, double *resPtr) const;
+ double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
+ static double ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr);
+ void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
public:
static NormalizedCellType TYPE;
};
{
public:
NormalizedCellType getType() const { return TYPE; }
- double computeForOneCell(const int *bg, const int *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
- static double ComputeForOneCellInternal(const int *bg, const int *endd, const double *coordsPtr);
- void computeForListOfCellIdsUMeshFrmt(const int *bgIds, const int *endIds, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeForRangeOfCellIdsUMeshFrmt(int bgId, int endId, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeFor1SGTUMeshFrmt(int nbOfCells, const int *connPtr, const double *coordsPtr, double *resPtr) const;
+ double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
+ static double ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr);
+ void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
public:
static NormalizedCellType TYPE;
};
{
public:
NormalizedCellType getType() const { return TYPE; }
- double computeForOneCell(const int *bg, const int *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
- static double ComputeForOneCellInternal(const int *bg, const int *endd, const double *coordsPtr);
- void computeForListOfCellIdsUMeshFrmt(const int *bgIds, const int *endIds, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeForRangeOfCellIdsUMeshFrmt(int bgId, int endId, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeFor1SGTUMeshFrmt(int nbOfCells, const int *connPtr, const double *coordsPtr, double *resPtr) const;
+ double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
+ static double ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr);
+ void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
public:
static NormalizedCellType TYPE;
};
{
public:
NormalizedCellType getType() const { return TYPE; }
- double computeForOneCell(const int *bg, const int *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
- static double ComputeForOneCellInternal(const int *bg, const int *endd, const double *coordsPtr);
- void computeForListOfCellIdsUMeshFrmt(const int *bgIds, const int *endIds, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeForRangeOfCellIdsUMeshFrmt(int bgId, int endId, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeFor1SGTUMeshFrmt(int nbOfCells, const int *connPtr, const double *coordsPtr, double *resPtr) const;
+ double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
+ static double ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr);
+ void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
public:
static NormalizedCellType TYPE;
};
{
public:
NormalizedCellType getType() const { return TYPE; }
- double computeForOneCell(const int *bg, const int *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
- static double ComputeForOneCellInternal(const int *bg, const int *endd, const double *coordsPtr);
- void computeForListOfCellIdsUMeshFrmt(const int *bgIds, const int *endIds, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeForRangeOfCellIdsUMeshFrmt(int bgId, int endId, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeFor1SGTUMeshFrmt(int nbOfCells, const int *connPtr, const double *coordsPtr, double *resPtr) const;
+ double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
+ static double ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr);
+ void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
public:
static NormalizedCellType TYPE;
};
{
public:
NormalizedCellType getType() const { return TYPE; }
- double computeForOneCell(const int *bg, const int *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
- static double ComputeForOneCellInternal(const int *bg, const int *endd, const double *coordsPtr);
- void computeForListOfCellIdsUMeshFrmt(const int *bgIds, const int *endIds, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeForRangeOfCellIdsUMeshFrmt(int bgId, int endId, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeFor1SGTUMeshFrmt(int nbOfCells, const int *connPtr, const double *coordsPtr, double *resPtr) const;
+ double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
+ static double ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr);
+ void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
public:
static NormalizedCellType TYPE;
};
{
public:
NormalizedCellType getType() const { return TYPE; }
- double computeForOneCell(const int *bg, const int *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
- static double ComputeForOneCellInternal(const int *bg, const int *endd, const double *coordsPtr);
- void computeForListOfCellIdsUMeshFrmt(const int *bgIds, const int *endIds, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeForRangeOfCellIdsUMeshFrmt(int bgId, int endId, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeFor1SGTUMeshFrmt(int nbOfCells, const int *connPtr, const double *coordsPtr, double *resPtr) const;
+ double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
+ static double ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr);
+ void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
public:
static NormalizedCellType TYPE;
};
{
public:
NormalizedCellType getType() const { return TYPE; }
- double computeForOneCell(const int *bg, const int *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
- static double ComputeForOneCellInternal(const int *bg, const int *endd, const double *coordsPtr);
- void computeForListOfCellIdsUMeshFrmt(const int *bgIds, const int *endIds, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeForRangeOfCellIdsUMeshFrmt(int bgId, int endId, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeFor1SGTUMeshFrmt(int nbOfCells, const int *connPtr, const double *coordsPtr, double *resPtr) const;
+ double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
+ static double ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr);
+ void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
public:
static NormalizedCellType TYPE;
};
{
public:
NormalizedCellType getType() const { return TYPE; }
- double computeForOneCell(const int *bg, const int *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
- static double ComputeForOneCellInternal(const int *bg, const int *endd, const double *coordsPtr);
- void computeForListOfCellIdsUMeshFrmt(const int *bgIds, const int *endIds, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeForRangeOfCellIdsUMeshFrmt(int bgId, int endId, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeFor1SGTUMeshFrmt(int nbOfCells, const int *connPtr, const double *coordsPtr, double *resPtr) const;
+ double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
+ static double ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr);
+ void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
public:
static NormalizedCellType TYPE;
};
{
public:
NormalizedCellType getType() const { return TYPE; }
- double computeForOneCell(const int *bg, const int *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
- static double ComputeForOneCellInternal(const int *bg, const int *endd, const double *coordsPtr);
- void computeForListOfCellIdsUMeshFrmt(const int *bgIds, const int *endIds, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeForRangeOfCellIdsUMeshFrmt(int bgId, int endId, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeFor1SGTUMeshFrmt(int nbOfCells, const int *connPtr, const double *coordsPtr, double *resPtr) const;
+ double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
+ static double ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr);
+ void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
public:
static NormalizedCellType TYPE;
};
{
public:
NormalizedCellType getType() const { return TYPE; }
- double computeForOneCell(const int *bg, const int *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
- static double ComputeForOneCellInternal(const int *bg, const int *endd, const double *coordsPtr);
- void computeForListOfCellIdsUMeshFrmt(const int *bgIds, const int *endIds, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeForRangeOfCellIdsUMeshFrmt(int bgId, int endId, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeFor1SGTUMeshFrmt(int nbOfCells, const int *connPtr, const double *coordsPtr, double *resPtr) const;
+ double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
+ static double ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr);
+ void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
public:
static NormalizedCellType TYPE;
};
{
public:
NormalizedCellType getType() const { return TYPE; }
- double computeForOneCell(const int *bg, const int *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
- static double ComputeForOneCellInternal(const int *bg, const int *endd, const double *coordsPtr);
- void computeForListOfCellIdsUMeshFrmt(const int *bgIds, const int *endIds, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeForRangeOfCellIdsUMeshFrmt(int bgId, int endId, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeFor1SGTUMeshFrmt(int nbOfCells, const int *connPtr, const double *coordsPtr, double *resPtr) const;
+ double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
+ static double ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr);
+ void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
public:
static NormalizedCellType TYPE;
};
{
public:
NormalizedCellType getType() const { return TYPE; }
- double computeForOneCell(const int *bg, const int *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
- static double ComputeForOneCellInternal(const int *bg, const int *endd, const double *coordsPtr);
- void computeForListOfCellIdsUMeshFrmt(const int *bgIds, const int *endIds, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeForRangeOfCellIdsUMeshFrmt(int bgId, int endId, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeFor1SGTUMeshFrmt(int nbOfCells, const int *connPtr, const double *coordsPtr, double *resPtr) const;
+ double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
+ static double ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr);
+ void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
public:
static NormalizedCellType TYPE;
};
{
public:
NormalizedCellType getType() const { return TYPE; }
- double computeForOneCell(const int *bg, const int *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
- static double ComputeForOneCellInternal(const int *bg, const int *endd, const double *coordsPtr);
- void computeForListOfCellIdsUMeshFrmt(const int *bgIds, const int *endIds, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeForRangeOfCellIdsUMeshFrmt(int bgId, int endId, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeFor1SGTUMeshFrmt(int nbOfCells, const int *connPtr, const double *coordsPtr, double *resPtr) const;
+ double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
+ static double ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr);
+ void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
public:
static NormalizedCellType TYPE;
};
{
public:
NormalizedCellType getType() const { return TYPE; }
- double computeForOneCell(const int *bg, const int *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
- static double ComputeForOneCellInternal(const int *bg, const int *endd, const double *coordsPtr);
- void computeForListOfCellIdsUMeshFrmt(const int *bgIds, const int *endIds, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeForRangeOfCellIdsUMeshFrmt(int bgId, int endId, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeFor1SGTUMeshFrmt(int nbOfCells, const int *connPtr, const double *coordsPtr, double *resPtr) const;
+ double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
+ static double ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr);
+ void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
public:
static NormalizedCellType TYPE;
};
{
public:
NormalizedCellType getType() const { return TYPE; }
- double computeForOneCell(const int *bg, const int *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
- static double ComputeForOneCellInternal(const int *bg, const int *endd, const double *coordsPtr);
- void computeForListOfCellIdsUMeshFrmt(const int *bgIds, const int *endIds, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeForRangeOfCellIdsUMeshFrmt(int bgId, int endId, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeFor1SGTUMeshFrmt(int nbOfCells, const int *connPtr, const double *coordsPtr, double *resPtr) const;
+ double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
+ static double ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr);
+ void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
public:
static NormalizedCellType TYPE;
};
{
public:
NormalizedCellType getType() const { return TYPE; }
- double computeForOneCell(const int *bg, const int *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
- static double ComputeForOneCellInternal(const int *bg, const int *endd, const double *coordsPtr);
- void computeForListOfCellIdsUMeshFrmt(const int *bgIds, const int *endIds, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeForRangeOfCellIdsUMeshFrmt(int bgId, int endId, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeFor1SGTUMeshFrmt(int nbOfCells, const int *connPtr, const double *coordsPtr, double *resPtr) const;
+ double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
+ static double ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr);
+ void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
public:
static NormalizedCellType TYPE;
};
{
public:
NormalizedCellType getType() const { return TYPE; }
- double computeForOneCell(const int *bg, const int *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
- static double ComputeForOneCellInternal(const int *bg, const int *endd, const double *coordsPtr);
- void computeForListOfCellIdsUMeshFrmt(const int *bgIds, const int *endIds, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeForRangeOfCellIdsUMeshFrmt(int bgId, int endId, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeFor1SGTUMeshFrmt(int nbOfCells, const int *connPtr, const double *coordsPtr, double *resPtr) const;
+ double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
+ static double ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr);
+ void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
public:
static NormalizedCellType TYPE;
};
{
public:
NormalizedCellType getType() const { return TYPE; }
- double computeForOneCell(const int *bg, const int *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
- static double ComputeForOneCellInternal(const int *bg, const int *endd, const double *coordsPtr);
- void computeForListOfCellIdsUMeshFrmt(const int *bgIds, const int *endIds, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeForRangeOfCellIdsUMeshFrmt(int bgId, int endId, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeFor1SGTUMeshFrmt(int nbOfCells, const int *connPtr, const double *coordsPtr, double *resPtr) const;
+ double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
+ static double ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr);
+ void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
public:
static NormalizedCellType TYPE;
};
{
public:
NormalizedCellType getType() const { return TYPE; }
- double computeForOneCell(const int *bg, const int *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
- static double ComputeForOneCellInternal(const int *bg, const int *endd, const double *coordsPtr);
- void computeForListOfCellIdsUMeshFrmt(const int *bgIds, const int *endIds, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeForRangeOfCellIdsUMeshFrmt(int bgId, int endId, const int *indPtr, const int *connPtr, const double *coordsPtr, double *resPtr) const;
- void computeFor1SGTUMeshFrmt(int nbOfCells, const int *connPtr, const double *coordsPtr, double *resPtr) const;
+ double computeForOneCell(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr) const { return ComputeForOneCellInternal(bg,endd,coordsPtr); }
+ static double ComputeForOneCellInternal(const mcIdType *bg, const mcIdType *endd, const double *coordsPtr);
+ void computeForListOfCellIdsUMeshFrmt(const mcIdType *bgIds, const mcIdType *endIds, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeForRangeOfCellIdsUMeshFrmt(mcIdType bgId, mcIdType endId, const mcIdType *indPtr, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
+ void computeFor1SGTUMeshFrmt(mcIdType nbOfCells, const mcIdType *connPtr, const double *coordsPtr, double *resPtr) const;
public:
static NormalizedCellType TYPE;
};
* It retrieves the same cell with a potentially different type (in return) whose connectivity is defined by (retConn,retLgth)
* \b WARNING for optimization reason the arrays 'retConn' and 'conn' can overlapped !
*/
-INTERP_KERNEL::NormalizedCellType CellSimplify::simplifyDegeneratedCell(INTERP_KERNEL::NormalizedCellType type, const int *conn, int lgth, int *retConn, int& retLgth)
+INTERP_KERNEL::NormalizedCellType CellSimplify::simplifyDegeneratedCell(INTERP_KERNEL::NormalizedCellType type, const mcIdType *conn, int lgth, mcIdType *retConn, int& retLgth)
{
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(type);
- std::set<int> c(conn,conn+lgth);
+ std::set<mcIdType> c(conn,conn+lgth);
c.erase(-1);
bool isObviousNonDegeneratedCell=((int)c.size()==lgth);
if((cm.getDimension()==3 && cm.isQuadratic()) || isObviousNonDegeneratedCell)
{//quadratic 3D, do nothing for the moment.
retLgth=lgth;
- int *tmp=new int[lgth];//no direct std::copy ! overlapping of conn and retConn !
+ mcIdType *tmp=new mcIdType[lgth];//no direct std::copy ! overlapping of conn and retConn !
std::copy(conn,conn+lgth,tmp);
std::copy(tmp,tmp+lgth,retConn);
delete [] tmp;
}
if(cm.getDimension()==2)
{
- int *tmp=new int[lgth];
+ mcIdType *tmp=new mcIdType[lgth];
int newPos=0;
if(!cm.isQuadratic())
{
else
{
int quadOff = lgth/2;
- int *tmpQuad = new int[quadOff];
+ mcIdType *tmpQuad = new mcIdType[quadOff];
for(int i = 0; i < quadOff; i++)
if(conn[i] != conn[(i+1)%quadOff] || conn[i] != conn[i+quadOff]) // zip nul segments/arcs (quad point must match too)
{
if(cm.getDimension()==3)
{
int nbOfFaces,lgthOfPolyhConn;
- int *zipFullReprOfPolyh=getFullPolyh3DCell(type,conn,lgth,nbOfFaces,lgthOfPolyhConn);
+ mcIdType *zipFullReprOfPolyh=getFullPolyh3DCell(type,conn,lgth,nbOfFaces,lgthOfPolyhConn);
INTERP_KERNEL::NormalizedCellType ret=tryToUnPoly3D(zipFullReprOfPolyh,nbOfFaces,lgthOfPolyhConn,retConn,retLgth);
delete [] zipFullReprOfPolyh;
return ret;
* This static method tries to unpolygonize a cell whose connectivity is given by 'conn' and 'lgth'.
* Contrary to INTERP_KERNEL::CellSimplify::simplifyDegeneratedCell method 'conn' and 'retConn' do not overlap.
*/
-INTERP_KERNEL::NormalizedCellType CellSimplify::tryToUnPoly2D(bool isQuad, const int *conn, int lgth, int *retConn, int& retLgth)
+INTERP_KERNEL::NormalizedCellType CellSimplify::tryToUnPoly2D(bool isQuad, const mcIdType *conn, int lgth, mcIdType *retConn, int& retLgth)
{
retLgth=lgth;
std::copy(conn,conn+lgth,retConn);
* The format of output array is the following :
* 1,2,3,-1,3,4,2,-1,3,4,1,-1,1,2,4,NORM_TRI3,NORM_TRI3,NORM_TRI3 (faces type at the end of classical polyhedron nodal description)
*/
-int *CellSimplify::getFullPolyh3DCell(INTERP_KERNEL::NormalizedCellType type, const int *conn, int lgth,
+mcIdType *CellSimplify::getFullPolyh3DCell(INTERP_KERNEL::NormalizedCellType type, const mcIdType *conn, int lgth,
int& retNbOfFaces, int& retLgth)
{
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(type);
unsigned nbOfFaces=cm.getNumberOfSons2(conn,lgth);
- int *tmp=new int[nbOfFaces*(lgth+1)];
- int *work=tmp;
- std::vector<int> faces;
+ mcIdType *tmp=new mcIdType[nbOfFaces*(lgth+1)];
+ mcIdType *work=tmp;
+ std::vector<mcIdType> faces;
for(unsigned j=0;j<nbOfFaces;j++)
{
INTERP_KERNEL::NormalizedCellType type2;
unsigned offset=cm.fillSonCellNodalConnectivity2(j,conn,lgth,work,type2);
//
- int *tmp2=new int[offset];
+ mcIdType *tmp2=new mcIdType[offset];
tmp2[0]=work[0];
int newPos=1;
for(unsigned k=1;k<offset;k++)
* method INTERP_KERNEL::CellSimplify::getFullPolyh3DCell ) and 'lgth'+'nbOfFaces'.
* Contrary to INTERP_KERNEL::CellSimplify::simplifyDegeneratedCell method 'conn' and 'retConn' do not overlap.
*/
-INTERP_KERNEL::NormalizedCellType CellSimplify::tryToUnPoly3D(const int *conn, int nbOfFaces, int lgth, int *retConn, int& retLgth)
+INTERP_KERNEL::NormalizedCellType CellSimplify::tryToUnPoly3D(const mcIdType *conn, int nbOfFaces, int lgth, mcIdType *retConn, int& retLgth)
{
- std::set<int> nodes(conn,conn+lgth);
+ std::set<mcIdType> nodes(conn,conn+lgth);
nodes.erase(-1);
int nbOfNodes=(int)nodes.size();
int magicNumber=100*nbOfNodes+nbOfFaces;
}
}
-bool CellSimplify::orientOppositeFace(const int *baseFace, int *retConn, const int *sideFace, int lgthBaseFace)
+bool CellSimplify::orientOppositeFace(const mcIdType *baseFace, mcIdType *retConn, const mcIdType *sideFace, int lgthBaseFace)
{
- std::vector<int> tmp2;
- std::set<int> bases(baseFace,baseFace+lgthBaseFace);
- std::set<int> sides(sideFace,sideFace+4);
- std::set_intersection(bases.begin(),bases.end(),sides.begin(),sides.end(),std::back_insert_iterator< std::vector<int> >(tmp2));
+ std::vector<mcIdType> tmp2;
+ std::set<mcIdType> bases(baseFace,baseFace+lgthBaseFace);
+ std::set<mcIdType> sides(sideFace,sideFace+4);
+ std::set_intersection(bases.begin(),bases.end(),sides.begin(),sides.end(),std::back_insert_iterator< std::vector<mcIdType> >(tmp2));
if(tmp2.size()!=2)
return false;
- std::vector< std::pair<int,int> > baseEdges(lgthBaseFace);
- std::vector< std::pair<int,int> > oppEdges(lgthBaseFace);
- std::vector< std::pair<int,int> > sideEdges(4);
+ std::vector< std::pair<mcIdType,mcIdType> > baseEdges(lgthBaseFace);
+ std::vector< std::pair<mcIdType,mcIdType> > oppEdges(lgthBaseFace);
+ std::vector< std::pair<mcIdType,mcIdType> > sideEdges(4);
for(int i=0;i<lgthBaseFace;i++)
{
- baseEdges[i]=std::pair<int,int>(baseFace[i],baseFace[(i+1)%lgthBaseFace]);
- oppEdges[i]=std::pair<int,int>(retConn[i],retConn[(i+1)%lgthBaseFace]);
+ baseEdges[i]=std::pair<mcIdType,mcIdType>(baseFace[i],baseFace[(i+1)%lgthBaseFace]);
+ oppEdges[i]=std::pair<mcIdType,mcIdType>(retConn[i],retConn[(i+1)%lgthBaseFace]);
}
for(int i=0;i<4;i++)
- sideEdges[i]=std::pair<int,int>(sideFace[i],sideFace[(i+1)%4]);
- std::vector< std::pair<int,int> > tmp;
- std::set< std::pair<int,int> > baseEdgesS(baseEdges.begin(),baseEdges.end());
- std::set< std::pair<int,int> > sideEdgesS(sideEdges.begin(),sideEdges.end());
- std::set_intersection(baseEdgesS.begin(),baseEdgesS.end(),sideEdgesS.begin(),sideEdgesS.end(),std::back_insert_iterator< std::vector< std::pair<int,int> > >(tmp));
+ sideEdges[i]=std::pair<mcIdType,mcIdType>(sideFace[i],sideFace[(i+1)%4]);
+ std::vector< std::pair<mcIdType,mcIdType> > tmp;
+ std::set< std::pair<mcIdType,mcIdType> > baseEdgesS(baseEdges.begin(),baseEdges.end());
+ std::set< std::pair<mcIdType,mcIdType> > sideEdgesS(sideEdges.begin(),sideEdges.end());
+ std::set_intersection(baseEdgesS.begin(),baseEdgesS.end(),sideEdgesS.begin(),sideEdgesS.end(),std::back_insert_iterator< std::vector< std::pair<mcIdType,mcIdType> > >(tmp));
if(tmp.empty())
{
//reverse sideFace
for(int i=0;i<4;i++)
{
- std::pair<int,int> p=sideEdges[i];
- std::pair<int,int> r(p.second,p.first);
+ std::pair<mcIdType,mcIdType> p=sideEdges[i];
+ std::pair<mcIdType,mcIdType> r(p.second,p.first);
sideEdges[i]=r;
}
//end reverse sideFace
- std::set< std::pair<int,int> > baseEdgesS2(baseEdges.begin(),baseEdges.end());
- std::set< std::pair<int,int> > sideEdgesS2(sideEdges.begin(),sideEdges.end());
- std::set_intersection(baseEdgesS2.begin(),baseEdgesS2.end(),sideEdgesS2.begin(),sideEdgesS2.end(),std::back_insert_iterator< std::vector< std::pair<int,int> > >(tmp));
+ std::set< std::pair<mcIdType,mcIdType> > baseEdgesS2(baseEdges.begin(),baseEdges.end());
+ std::set< std::pair<mcIdType,mcIdType> > sideEdgesS2(sideEdges.begin(),sideEdges.end());
+ std::set_intersection(baseEdgesS2.begin(),baseEdgesS2.end(),sideEdgesS2.begin(),sideEdgesS2.end(),std::back_insert_iterator< std::vector< std::pair<mcIdType,mcIdType> > >(tmp));
if(tmp.empty())
return false;
}
if(tmp.size()!=1)
return false;
bool found=false;
- std::pair<int,int> pInOpp;
+ std::pair<mcIdType,mcIdType> pInOpp;
for(int i=0;i<4 && !found;i++)
{//finding the pair(edge) in sideFace that do not include any node of tmp[0] edge
found=(tmp[0].first!=sideEdges[i].first && tmp[0].first!=sideEdges[i].second &&
if(!found)
return false;
int pos=(int)std::distance(baseEdges.begin(),std::find(baseEdges.begin(),baseEdges.end(),tmp[0]));
- std::vector< std::pair<int,int> >::iterator it=std::find(oppEdges.begin(),oppEdges.end(),pInOpp);
+ std::vector< std::pair<mcIdType,mcIdType> >::iterator it=std::find(oppEdges.begin(),oppEdges.end(),pInOpp);
if(it==oppEdges.end())//the opposite edge of side face is not found opposite face ... maybe problem of orientation of polyhedron
return false;
int pos2=(int)std::distance(oppEdges.begin(),it);
if(offset<0)
offset+=lgthBaseFace;
//this is the end copy the result
- int *tmp3=new int[lgthBaseFace];
+ mcIdType *tmp3=new mcIdType[lgthBaseFace];
for(int i=0;i<lgthBaseFace;i++)
tmp3[(offset+i)%lgthBaseFace]=oppEdges[i].first;
std::copy(tmp3,tmp3+lgthBaseFace,retConn);
return true;
}
-bool CellSimplify::isWellOriented(const int *baseFace, int *retConn, const int *sideFace, int lgthBaseFace)
+bool CellSimplify::isWellOriented(const mcIdType *baseFace, mcIdType *retConn, const mcIdType *sideFace, int lgthBaseFace)
{
return true;
}
* k_th node in retConnOfOppFace. Excluded faces 'baseFace' and 'oppFace' all the other faces in 'conn' must be QUAD4 faces.
* If the arrangement process succeeds true is returned and retConnOfOppFace is filled.
*/
-bool CellSimplify::tryToArrangeOppositeFace(const int *conn, int lgth, int lgthBaseFace, const int *baseFace, const int *oppFace, int nbOfFaces, int *retConnOfOppFace)
+bool CellSimplify::tryToArrangeOppositeFace(const mcIdType *conn, int lgth, int lgthBaseFace, const mcIdType *baseFace, const mcIdType *oppFace, int nbOfFaces, mcIdType *retConnOfOppFace)
{
retConnOfOppFace[0]=oppFace[0];
for(int j=1;j<lgthBaseFace;j++)
retConnOfOppFace[j]=oppFace[lgthBaseFace-j];
- const int *curFace=conn;
+ const mcIdType *curFace=conn;
int sideFace=0;
bool ret=true;
for(int i=0;i<nbOfFaces && ret;i++)
* This method is only callable if in 'conn' there is 8 nodes and 6 faces.
* If fails a POLYHED is returned.
*/
-INTERP_KERNEL::NormalizedCellType CellSimplify::tryToUnPolyHex8(const int *conn, int nbOfFaces, int lgth, int *retConn, int& retLgth)
+INTERP_KERNEL::NormalizedCellType CellSimplify::tryToUnPolyHex8(const mcIdType *conn, int nbOfFaces, int lgth, mcIdType *retConn, int& retLgth)
{
- if(std::find_if(conn+lgth,conn+lgth+nbOfFaces,std::bind2nd(std::not_equal_to<int>(),(int)INTERP_KERNEL::NORM_QUAD4))==conn+lgth+nbOfFaces)
+ if(std::find_if(conn+lgth,conn+lgth+nbOfFaces,std::bind2nd(std::not_equal_to<mcIdType>(),(mcIdType)INTERP_KERNEL::NORM_QUAD4))==conn+lgth+nbOfFaces)
{//6 faces are QUAD4.
int oppositeFace=-1;
- std::set<int> conn1(conn,conn+4);
+ std::set<mcIdType> conn1(conn,conn+4);
for(int i=1;i<6 && oppositeFace<0;i++)
{
- std::vector<int> tmp;
- std::set<int> conn2(conn+5*i,conn+5*i+4);
- std::set_intersection(conn1.begin(),conn1.end(),conn2.begin(),conn2.end(),std::back_insert_iterator< std::vector<int> >(tmp));
+ std::vector<mcIdType> tmp;
+ std::set<mcIdType> conn2(conn+5*i,conn+5*i+4);
+ std::set_intersection(conn1.begin(),conn1.end(),conn2.begin(),conn2.end(),std::back_insert_iterator< std::vector<mcIdType> >(tmp));
if(tmp.empty())
oppositeFace=i;
}
if(oppositeFace>=1)
{//oppositeFace of face#0 found.
- int tmp2[4];
+ mcIdType tmp2[4];
if(tryToArrangeOppositeFace(conn,lgth,4,conn,conn+5*oppositeFace,6,tmp2))
{
std::copy(conn,conn+4,retConn);
return INTERP_KERNEL::NORM_POLYHED;
}
-INTERP_KERNEL::NormalizedCellType CellSimplify::tryToUnPolyHexp12(const int *conn, int nbOfFaces, int lgth, int *retConn, int& retLgth)
+INTERP_KERNEL::NormalizedCellType CellSimplify::tryToUnPolyHexp12(const mcIdType *conn, int nbOfFaces, int lgth, mcIdType *retConn, int& retLgth)
{
- std::size_t nbOfHexagon=std::count(conn+lgth,conn+lgth+nbOfFaces,(int)INTERP_KERNEL::NORM_POLYGON);
- std::size_t nbOfQuad=std::count(conn+lgth,conn+lgth+nbOfFaces,(int)INTERP_KERNEL::NORM_QUAD4);
+ std::size_t nbOfHexagon=std::count(conn+lgth,conn+lgth+nbOfFaces,(mcIdType)INTERP_KERNEL::NORM_POLYGON);
+ std::size_t nbOfQuad=std::count(conn+lgth,conn+lgth+nbOfFaces,(mcIdType)INTERP_KERNEL::NORM_QUAD4);
if(nbOfQuad==6 && nbOfHexagon==2)
{
- const int *hexag0=std::find(conn+lgth,conn+lgth+nbOfFaces,(int)INTERP_KERNEL::NORM_POLYGON);
+ const mcIdType *hexag0=std::find(conn+lgth,conn+lgth+nbOfFaces,(mcIdType)INTERP_KERNEL::NORM_POLYGON);
std::size_t hexg0Id=std::distance(conn+lgth,hexag0);
- const int *hexag1=std::find(hexag0+1,conn+lgth+nbOfFaces,(int)INTERP_KERNEL::NORM_POLYGON);
+ const mcIdType *hexag1=std::find(hexag0+1,conn+lgth+nbOfFaces,(mcIdType)INTERP_KERNEL::NORM_POLYGON);
std::size_t hexg1Id=std::distance(conn+lgth,hexag1);
- const int *connHexag0=conn+5*hexg0Id;
+ const mcIdType *connHexag0=conn+5*hexg0Id;
std::size_t lgthH0=std::distance(connHexag0,std::find(connHexag0,conn+lgth,-1));
if(lgthH0==6)
{
- const int *connHexag1=conn+5*hexg0Id+7+(hexg1Id-hexg0Id-1)*5;
+ const mcIdType *connHexag1=conn+5*hexg0Id+7+(hexg1Id-hexg0Id-1)*5;
std::size_t lgthH1=std::distance(connHexag1,std::find(connHexag1,conn+lgth,-1));
if(lgthH1==6)
{
- std::vector<int> tmp;
- std::set<int> conn1(connHexag0,connHexag0+6);
- std::set<int> conn2(connHexag1,connHexag1+6);
- std::set_intersection(conn1.begin(),conn1.end(),conn2.begin(),conn2.end(),std::back_insert_iterator< std::vector<int> >(tmp));
+ std::vector<mcIdType> tmp;
+ std::set<mcIdType> conn1(connHexag0,connHexag0+6);
+ std::set<mcIdType> conn2(connHexag1,connHexag1+6);
+ std::set_intersection(conn1.begin(),conn1.end(),conn2.begin(),conn2.end(),std::back_insert_iterator< std::vector<mcIdType> >(tmp));
if(tmp.empty())
{
- int tmp2[6];
+ mcIdType tmp2[6];
if(tryToArrangeOppositeFace(conn,lgth,6,connHexag0,connHexag1,8,tmp2))
{
std::copy(connHexag0,connHexag0+6,retConn);
* Cell with 'conn' connectivity has been detected as a good candidate. Full check of this. If yes NORM_PENTA6 is returned.
* If fails a POLYHED is returned.
*/
-INTERP_KERNEL::NormalizedCellType CellSimplify::tryToUnPolyPenta6(const int *conn, int nbOfFaces, int lgth, int *retConn, int& retLgth)
+INTERP_KERNEL::NormalizedCellType CellSimplify::tryToUnPolyPenta6(const mcIdType *conn, int nbOfFaces, int lgth, mcIdType *retConn, int& retLgth)
{
- std::size_t nbOfTriFace=std::count(conn+lgth,conn+lgth+nbOfFaces,(int)INTERP_KERNEL::NORM_TRI3);
- std::size_t nbOfQuadFace=std::count(conn+lgth,conn+lgth+nbOfFaces,(int)INTERP_KERNEL::NORM_QUAD4);
+ std::size_t nbOfTriFace=std::count(conn+lgth,conn+lgth+nbOfFaces,(mcIdType)INTERP_KERNEL::NORM_TRI3);
+ std::size_t nbOfQuadFace=std::count(conn+lgth,conn+lgth+nbOfFaces,(mcIdType)INTERP_KERNEL::NORM_QUAD4);
if(nbOfTriFace==2 && nbOfQuadFace==3)
{
- std::size_t tri3_0=std::distance(conn+lgth,std::find(conn+lgth,conn+lgth+nbOfFaces,(int)INTERP_KERNEL::NORM_TRI3));
- std::size_t tri3_1=std::distance(conn+lgth,std::find(conn+lgth+tri3_0+1,conn+lgth+nbOfFaces,(int)INTERP_KERNEL::NORM_TRI3));
- const int *tri_0=0,*tri_1=0;
- const int *w=conn;
+ std::size_t tri3_0=std::distance(conn+lgth,std::find(conn+lgth,conn+lgth+nbOfFaces,(mcIdType)INTERP_KERNEL::NORM_TRI3));
+ std::size_t tri3_1=std::distance(conn+lgth,std::find(conn+lgth+tri3_0+1,conn+lgth+nbOfFaces,(mcIdType)INTERP_KERNEL::NORM_TRI3));
+ const mcIdType *tri_0=0,*tri_1=0;
+ const mcIdType *w=conn;
for(std::size_t i=0;i<5;i++)
{
if(i==tri3_0)
w=std::find(w,conn+lgth,-1);
w++;
}
- std::vector<int> tmp;
- std::set<int> conn1(tri_0,tri_0+3);
- std::set<int> conn2(tri_1,tri_1+3);
- std::set_intersection(conn1.begin(),conn1.end(),conn2.begin(),conn2.end(),std::back_insert_iterator< std::vector<int> >(tmp));
+ std::vector<mcIdType> tmp;
+ std::set<mcIdType> conn1(tri_0,tri_0+3);
+ std::set<mcIdType> conn2(tri_1,tri_1+3);
+ std::set_intersection(conn1.begin(),conn1.end(),conn2.begin(),conn2.end(),std::back_insert_iterator< std::vector<mcIdType> >(tmp));
if(tmp.empty())
{
- int tmp2[3];
+ mcIdType tmp2[3];
if(tryToArrangeOppositeFace(conn,lgth,3,tri_0,tri_1,5,tmp2))
{
std::copy(tri_0,tri_0+3,retConn);
* Cell with 'conn' connectivity has been detected as a good candidate. Full check of this. If yes NORM_PYRA5 is returned.
* If fails a POLYHED is returned.
*/
-INTERP_KERNEL::NormalizedCellType CellSimplify::tryToUnPolyPyra5(const int *conn, int nbOfFaces, int lgth, int *retConn, int& retLgth)
+INTERP_KERNEL::NormalizedCellType CellSimplify::tryToUnPolyPyra5(const mcIdType *conn, int nbOfFaces, int lgth, mcIdType *retConn, int& retLgth)
{
- std::size_t nbOfTriFace=std::count(conn+lgth,conn+lgth+nbOfFaces,(int)INTERP_KERNEL::NORM_TRI3);
- std::size_t nbOfQuadFace=std::count(conn+lgth,conn+lgth+nbOfFaces,(int)INTERP_KERNEL::NORM_QUAD4);
+ std::size_t nbOfTriFace=std::count(conn+lgth,conn+lgth+nbOfFaces,(mcIdType)INTERP_KERNEL::NORM_TRI3);
+ std::size_t nbOfQuadFace=std::count(conn+lgth,conn+lgth+nbOfFaces,(mcIdType)INTERP_KERNEL::NORM_QUAD4);
if(nbOfTriFace==4 && nbOfQuadFace==1)
{
- std::size_t quad4_pos=std::distance(conn+lgth,std::find(conn+lgth,conn+lgth+nbOfFaces,(int)INTERP_KERNEL::NORM_QUAD4));
- const int *quad4=0;
- const int *w=conn;
+ std::size_t quad4_pos=std::distance(conn+lgth,std::find(conn+lgth,conn+lgth+nbOfFaces,(mcIdType)INTERP_KERNEL::NORM_QUAD4));
+ const mcIdType *quad4=0;
+ const mcIdType *w=conn;
for(std::size_t i=0;i<5 && quad4==0;i++)
{
if(i==quad4_pos)
w=std::find(w,conn+lgth,-1);
w++;
}
- std::set<int> quad4S(quad4,quad4+4);
+ std::set<mcIdType> quad4S(quad4,quad4+4);
w=conn;
bool ok=true;
int point=-1;
{
if(i!=quad4_pos)
{
- std::vector<int> tmp;
- std::set<int> conn2(w,w+3);
- std::set_intersection(conn2.begin(),conn2.end(),quad4S.begin(),quad4S.end(),std::back_insert_iterator< std::vector<int> >(tmp));
+ std::vector<mcIdType> tmp;
+ std::set<mcIdType> conn2(w,w+3);
+ std::set_intersection(conn2.begin(),conn2.end(),quad4S.begin(),quad4S.end(),std::back_insert_iterator< std::vector<mcIdType> >(tmp));
ok=tmp.size()==2;
tmp.clear();
- std::set_difference(conn2.begin(),conn2.end(),quad4S.begin(),quad4S.end(),std::back_insert_iterator< std::vector<int> >(tmp));
+ std::set_difference(conn2.begin(),conn2.end(),quad4S.begin(),quad4S.end(),std::back_insert_iterator< std::vector<mcIdType> >(tmp));
ok=ok && tmp.size()==1;
if(ok)
{
* Cell with 'conn' connectivity has been detected as a good candidate. Full check of this. If yes NORM_TETRA4 is returned.
* If fails a POLYHED is returned.
*/
-INTERP_KERNEL::NormalizedCellType CellSimplify::tryToUnPolyTetra4(const int *conn, int nbOfFaces, int lgth, int *retConn, int& retLgth)
+INTERP_KERNEL::NormalizedCellType CellSimplify::tryToUnPolyTetra4(const mcIdType *conn, int nbOfFaces, int lgth, mcIdType *retConn, int& retLgth)
{
- if(std::find_if(conn+lgth,conn+lgth+nbOfFaces,std::bind2nd(std::not_equal_to<int>(),(int)INTERP_KERNEL::NORM_TRI3))==conn+lgth+nbOfFaces)
+ if(std::find_if(conn+lgth,conn+lgth+nbOfFaces,std::bind2nd(std::not_equal_to<mcIdType>(),(mcIdType)INTERP_KERNEL::NORM_TRI3))==conn+lgth+nbOfFaces)
{
- std::set<int> tribase(conn,conn+3);
+ std::set<mcIdType> tribase(conn,conn+3);
int point=-1;
bool ok=true;
for(int i=1;i<4 && ok;i++)
{
- std::vector<int> tmp;
- std::set<int> conn2(conn+i*4,conn+4*i+3);
- std::set_intersection(conn2.begin(),conn2.end(),tribase.begin(),tribase.end(),std::back_insert_iterator< std::vector<int> >(tmp));
+ std::vector<mcIdType> tmp;
+ std::set<mcIdType> conn2(conn+i*4,conn+4*i+3);
+ std::set_intersection(conn2.begin(),conn2.end(),tribase.begin(),tribase.end(),std::back_insert_iterator< std::vector<mcIdType> >(tmp));
ok=tmp.size()==2;
tmp.clear();
- std::set_difference(conn2.begin(),conn2.end(),tribase.begin(),tribase.end(),std::back_insert_iterator< std::vector<int> >(tmp));
+ std::set_difference(conn2.begin(),conn2.end(),tribase.begin(),tribase.end(),std::back_insert_iterator< std::vector<mcIdType> >(tmp));
ok=ok && tmp.size()==1;
if(ok)
{
* - fully degenerated polygons (polygon with 1 point, or 2 if quadratic)
* - quad polygon with 2 points and two identical quad points
*/
-bool CellSimplify::isFlatCell(const int* conn, int pos, int lgth, NormalizedCellType type)
+bool CellSimplify::isFlatCell(const mcIdType* conn, mcIdType pos, int lgth, NormalizedCellType type)
{
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(type);
if ( lgth <= 2 ) // a polygon with a single, or two points has been returned. This check also captures degenerated quadratics
#include "INTERPKERNELDefines.hxx"
#include "NormalizedUnstructuredMesh.hxx"
#include "InterpKernelException.hxx"
+#include "MCIdType.hxx"
namespace INTERP_KERNEL
{
class INTERPKERNEL_EXPORT CellSimplify
{
public:
- static INTERP_KERNEL::NormalizedCellType simplifyDegeneratedCell(INTERP_KERNEL::NormalizedCellType type, const int *conn, int lgth, int *retConn, int& retLgth);
- static int *getFullPolyh3DCell(INTERP_KERNEL::NormalizedCellType type, const int *conn, int lgth,
+ static INTERP_KERNEL::NormalizedCellType simplifyDegeneratedCell(INTERP_KERNEL::NormalizedCellType type, const mcIdType *conn, int lgth, mcIdType *retConn, int& retLgth);
+ static mcIdType *getFullPolyh3DCell(INTERP_KERNEL::NormalizedCellType type, const mcIdType *conn, int lgth,
int& retNbOfFaces, int& retLgth);
- static INTERP_KERNEL::NormalizedCellType tryToUnPoly2D(bool isQuad, const int *conn, int lgth, int *retConn, int& retLgth);
- static INTERP_KERNEL::NormalizedCellType tryToUnPoly3D(const int *conn, int nbOfFaces, int lgth, int *retConn, int& retLgth);
- static INTERP_KERNEL::NormalizedCellType tryToUnPolyHex8(const int *conn, int nbOfFaces, int lgth, int *retConn, int& retLgth);
- static INTERP_KERNEL::NormalizedCellType tryToUnPolyHexp12(const int *conn, int nbOfFaces, int lgth, int *retConn, int& retLgth);
- static INTERP_KERNEL::NormalizedCellType tryToUnPolyPenta6(const int *conn, int nbOfFaces, int lgth, int *retConn, int& retLgth);
- static INTERP_KERNEL::NormalizedCellType tryToUnPolyPyra5(const int *conn, int nbOfFaces, int lgth, int *retConn, int& retLgth);
- static INTERP_KERNEL::NormalizedCellType tryToUnPolyTetra4(const int *conn, int nbOfFaces, int lgth, int *retConn, int& retLgth);
- static bool tryToArrangeOppositeFace(const int *conn, int lgth, int lgthBaseFace, const int *baseFace, const int *oppFaceId, int nbOfFaces, int *retConnOfOppFace);
- static bool isWellOriented(const int *baseFace, int *retConn, const int *sideFace, int lgthBaseFace);
- static bool orientOppositeFace(const int *baseFace, int *retConn, const int *sideFace, int lgthBaseFace);
- static bool isFlatCell(const int* conn, int pos, int lgth, NormalizedCellType type);
+ static INTERP_KERNEL::NormalizedCellType tryToUnPoly2D(bool isQuad, const mcIdType *conn, int lgth, mcIdType *retConn, int& retLgth);
+ static INTERP_KERNEL::NormalizedCellType tryToUnPoly3D(const mcIdType *conn, int nbOfFaces, int lgth, mcIdType *retConn, int& retLgth);
+ static INTERP_KERNEL::NormalizedCellType tryToUnPolyHex8(const mcIdType *conn, int nbOfFaces, int lgth, mcIdType *retConn, int& retLgth);
+ static INTERP_KERNEL::NormalizedCellType tryToUnPolyHexp12(const mcIdType *conn, int nbOfFaces, int lgth, mcIdType *retConn, int& retLgth);
+ static INTERP_KERNEL::NormalizedCellType tryToUnPolyPenta6(const mcIdType *conn, int nbOfFaces, int lgth, mcIdType *retConn, int& retLgth);
+ static INTERP_KERNEL::NormalizedCellType tryToUnPolyPyra5(const mcIdType *conn, int nbOfFaces, int lgth, mcIdType *retConn, int& retLgth);
+ static INTERP_KERNEL::NormalizedCellType tryToUnPolyTetra4(const mcIdType *conn, int nbOfFaces, int lgth, mcIdType *retConn, int& retLgth);
+ static bool tryToArrangeOppositeFace(const mcIdType *conn, int lgth, int lgthBaseFace, const mcIdType *baseFace, const mcIdType *oppFaceId, int nbOfFaces, mcIdType *retConnOfOppFace);
+ static bool isWellOriented(const mcIdType *baseFace, mcIdType *retConn, const mcIdType *sideFace, int lgthBaseFace);
+ static bool orientOppositeFace(const mcIdType *baseFace, mcIdType *retConn, const mcIdType *sideFace, int lgthBaseFace);
+ static bool isFlatCell(const mcIdType* conn, mcIdType pos, int lgth, NormalizedCellType type);
};
}
* \param [in] incy the increment between successive entries in \a dy.
* \return the sum of the product of the corresponding entries of \a dx and \a dy.
*/
- double ddot(int n, const double *dx, int incx, const double *dy, int incy)
+ double ddot(mcIdType n, const double *dx, mcIdType incx, const double *dy, mcIdType incy)
{
double dtemp=0.0;
- int i,ix,iy,m;
+ mcIdType i,ix,iy,m;
if(n<=0)
return dtemp;
// Code for unequal increments or equal increments not equal to 1.
}
- void dscal(int n, double sa, double *x, int incx)
+ void dscal(mcIdType n, double sa, double *x, mcIdType incx)
{
- int i,ix,m;
+ mcIdType i,ix,m;
if(n<=0) { }
else if(incx==1)
}
}
- void daxpy(int n, double da, const double *dx, int incx, double *dy, int incy)
+ void daxpy(mcIdType n, double da, const double *dx, mcIdType incx, double *dy, mcIdType incy)
{
- int i,ix,iy,m;
+ mcIdType i,ix,iy,m;
if (n<=0)
return;
if (da==0.0)
return -x;
}
- void dswap(int n, double *x, int incx, double *y, int incy)
+ void dswap(mcIdType n, double *x, mcIdType incx, double *y, mcIdType incy)
{
- int i,ix,iy,m;
+ mcIdType i,ix,iy,m;
double temp;
if(n<=0) { }
* \param [in] incx the increment between successive entries of SX.
* \return the index of the element of maximum absolute value (in C convention).
*/
- int idamax(int n, const double *dx, int incx)
+ mcIdType idamax(mcIdType n, const double *dx, mcIdType incx)
{
double dmax;
- int i,ix,value;
+ mcIdType i,ix,value;
value=-1;
if ( n < 1 || incx <= 0 )
return value;
* - K, if U(K-1,K-1) == 0. This is not an error condition for this subroutine,
* but it does indicate that DGESL or DGEDI will divide by zero if called.
*/
- int dgefa(double *a, int lda, int n, int *ipvt)
+ mcIdType dgefa(double *a, mcIdType lda, mcIdType n, mcIdType *ipvt)
{
- int info=0;
- int l;
+ mcIdType info=0;
+ mcIdType l;
double t;
// Gaussian elimination with partial pivoting.
- for(int k=0;k<n-1;k++)
+ for(mcIdType k=0;k<n-1;k++)
{
// Find L=pivot index.
l=idamax(n-k,a+k+k*lda,1)+k;
t=-1.0/a[k+k*lda];
dscal(n-k-1,t,a+k+1+k*lda,1);
// Row elimination with column indexing.
- for(int j=k+1;j<n;j++)
+ for(mcIdType j=k+1;j<n;j++)
{
t=a[l+j*lda];
if(l!=k)
* \param [in] ipvt, the pivot vector from dgfa.
* \param [in,out] work a work array of size at least equal to \a n.
*/
- void dgedi(double *a, int lda, int n, const int *ipvt, double *work)
+ void dgedi(double *a, mcIdType lda, mcIdType n, const mcIdType *ipvt, double *work)
{
double t;
- for(int k=0;k<n;k++)
+ for(mcIdType k=0;k<n;k++)
{
a[k+k*lda]=1.0/a[k+k*lda];
t=-a[k+k*lda];
dscal(k,t,a+0+k*lda,1);
- for(int j=k+1;j<n;j++)
+ for(mcIdType j=k+1;j<n;j++)
{
t=a[k+j*lda];
a[k+j*lda]=0.0;
}
}
// Form inverse(U) * inverse(L).
- for(int k=n-2;k>=0;k--)
+ for(mcIdType k=n-2;k>=0;k--)
{
- for(int i=k+1;i<n;i++)
+ for(mcIdType i=k+1;i<n;i++)
{
work[i]=a[i+k*lda];
a[i+k*lda]=0.0;
}
- for(int j=k+1;j<n;j++)
+ for(mcIdType j=k+1;j<n;j++)
{
t=work[j];
daxpy(n,t,a+0+j*lda,1,a+0+k*lda,1);
}
- int l=ipvt[k];
+ mcIdType l=ipvt[k];
if(l!=k-1)
dswap(n,a+0+k*lda,1,a+0+l*lda,1);
}
}
- void matrixProduct(const double *A, int n1, int p1, const double *B, int n2, int p2, double *C)
+ void matrixProduct(const double *A, mcIdType n1, mcIdType p1, const double *B, mcIdType n2, mcIdType p2, double *C)
{
if(p1!=n2)
{
std::ostringstream oss; oss << "matrixProduct : the size of input matrix are not coherent the nb of cols of input matrix #0 is " << p1 << " whereas the number of rows of input matrix #1 is " << n2 << " !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
- for(int i=0;i<n1;i++)
+ for(mcIdType i=0;i<n1;i++)
{
+ for(
mcIdType j=0;j<p2;j++)
{
C[i*p2+j] = 0.;
+ for(
mcIdType k=0;k<p1;k++)
C[i*p2+j]+=A[i*p1+k]*B[k*p2+j];
}
}
}
- void inverseMatrix(const double *A, int n, double *iA)
+ void inverseMatrix(const double *A, mcIdType n, double *iA)
{
- INTERP_KERNEL::AutoPtr<int> ipvt=new int[n];
+ INTERP_KERNEL::AutoPtr<mcIdType> ipvt=new mcIdType[n];
INTERP_KERNEL::AutoPtr<double> work=new double[n*n];
std::copy(A,A+n*n,iA);
dgefa(iA,n,n,ipvt);
#define __INTERPKERNELMATRIXTOOLS_HXX__
#include "INTERPKERNELDefines.hxx"
+#include "MCIdType.hxx"
namespace INTERP_KERNEL
{
- void INTERPKERNEL_EXPORT matrixProduct(const double *A, int n1, int p1, const double *B, int n2, int p2, double *C);
- void INTERPKERNEL_EXPORT inverseMatrix(const double *A, int n, double *iA);
- void INTERPKERNEL_EXPORT daxpy(int n, double da, const double *dx, int incx, double *dy, int incy);
+ void INTERPKERNEL_EXPORT matrixProduct(const double *A, mcIdType n1, mcIdType p1, const double *B, mcIdType n2, mcIdType p2, double *C);
+ void INTERPKERNEL_EXPORT inverseMatrix(const double *A, mcIdType n, double *iA);
+ void INTERPKERNEL_EXPORT daxpy(mcIdType n, double da, const double *dx, mcIdType incx, double *dy, mcIdType incy);
}
#endif
Interpolation(const InterpolationOptions& io) :InterpolationOptions(io){}
//interpolation of two triangular meshes.
template<class MatrixType, class MyMeshType>
- int interpolateMeshes(const MyMeshType& meshS, const MyMeshType& meshT, MatrixType& result)
+ typename MyMeshType::MyConnType interpolateMeshes(const MyMeshType& meshS, const MyMeshType& meshT, MatrixType& result)
{ return asLeaf().interpolateMeshes(meshS,meshT,result); }
template<class MyMeshType, class MatrixType>
- int fromIntegralUniform(const MyMeshType& meshT, MatrixType& result, const std::string& method) { return fromToIntegralUniform(false,meshT,result,method); }
+ typename MyMeshType::MyConnType fromIntegralUniform(const MyMeshType& meshT, MatrixType& result, const std::string& method) { return fromToIntegralUniform(false,meshT,result,method); }
template<class MyMeshType, class MatrixType>
- int toIntegralUniform(const MyMeshType& meshS, MatrixType& result, const std::string& method) { return fromToIntegralUniform(true,meshS,result,method); }
+ typename MyMeshType::MyConnType toIntegralUniform(const MyMeshType& meshS, MatrixType& result, const std::string& method) { return fromToIntegralUniform(true,meshS,result,method); }
template<class MyMeshType>
static double CalculateCharacteristicSizeOfMeshes(const MyMeshType& myMeshS, const MyMeshType& myMeshT, const int printLevel);
protected:
template<class MyMeshType, class MatrixType>
- int fromToIntegralUniform(bool fromTo, const MyMeshType& mesh, MatrixType& result, const std::string& method);
+ typename MyMeshType::MyConnType fromToIntegralUniform(bool fromTo, const MyMeshType& mesh, MatrixType& result, const std::string& method);
protected:
TrueMainInterpolator& asLeaf() { return static_cast<TrueMainInterpolator&>(*this); }
};
{
template<class TrueMainInterpolator>
template<class MyMeshType, class MatrixType>
- int Interpolation<TrueMainInterpolator>::fromToIntegralUniform(bool fromTo, const MyMeshType& mesh, MatrixType& result, const std::string& method)
+ typename MyMeshType::MyConnType Interpolation<TrueMainInterpolator>::fromToIntegralUniform(bool fromTo, const MyMeshType& mesh, MatrixType& result, const std::string& method)
{
typedef typename MyMeshType::MyConnType ConnType;
- int ret=-1;
+ ConnType ret=-1;
if(method=="P0")
{
IntegralUniformIntersectorP0<MyMeshType,MatrixType> intersector(mesh,InterpolationOptions::getMeasureAbsStatus());
/* Loop on the target cells - core of the algorithm */
/****************************************************/
long start_intersection=clock();
- long nbelem_type=myMeshT.getNumberOfElements();
+ ConnType nbelem_type=myMeshT.getNumberOfElements();
const ConnType *connIndxT=myMeshT.getConnectivityIndexPtr();
- for(int iT=0; iT<nbelem_type; iT++)
+ for(ConnType iT=0; iT<nbelem_type; iT++)
{
int nb_nodesT=connIndxT[iT+1]-connIndxT[iT];
- std::vector<int> intersecting_elems;
+ std::vector<ConnType> intersecting_elems;
double bb[2*SPACEDIM];
intersector->getElemBB(bb,myMeshT,OTT<ConnType,numPol>::indFC(iT),nb_nodesT);
my_tree.getIntersectingElems(bb, intersecting_elems);
counter+=intersecting_elems.size();
intersecting_elems.clear();
}
- int ret=intersector->getNumberOfColsOfResMatrix();
+ ConnType ret=intersector->getNumberOfColsOfResMatrix();
const DuplicateFacesType& intersectFaces = *intersector->getIntersectFaces();
DuplicateFacesType::const_iterator iter;
*
*/
template<class MyMeshType, class MyMatrixType>
- int Interpolation2D3D::interpolateMeshes(const MyMeshType& srcMesh,
+ ConnType Interpolation2D3D::interpolateMeshes(const MyMeshType& srcMesh,
const MyMeshType& targetMesh,
MyMatrixType& matrix,
const std::string& method)
std::vector<MeshElement<ConnType>*> srcElems(numSrcElems);
std::vector<MeshElement<ConnType>*> targetElems(numTargetElems);
- std::map<MeshElement<ConnType>*, int> indices;
+ std::map<MeshElement<ConnType>*, ConnType> indices;
DuplicateFacesType intersectFaces;
for(ConnType i = 0 ; i < numSrcElems ; ++i)
// create BBTree structure
// - get bounding boxes
double* bboxes = new double[6 * numSrcElems];
- int* srcElemIdx = new int[numSrcElems];
+ ConnType* srcElemIdx = new ConnType[numSrcElems];
for(ConnType i = 0; i < numSrcElems ; ++i)
{
// get source bboxes in right order
for(ConnType i = 0; i < numTargetElems; ++i)
{
const BoundingBox* box = targetElems[i]->getBoundingBox();
- const int targetIdx = targetElems[i]->getIndex();
+ const ConnType targetIdx = targetElems[i]->getIndex();
// get target bbox in right order
double targetBox[6];
}
// free allocated memory
- int ret=intersector->getNumberOfColsOfResMatrix();
+ ConnType ret=intersector->getNumberOfColsOfResMatrix();
delete intersector;
Interpolation3D();\r
Interpolation3D(const InterpolationOptions& io);\r
template<class MyMeshType, class MatrixType>\r
- int interpolateMeshes(const MyMeshType& srcMesh, const MyMeshType& targetMesh, MatrixType& result, const std::string& method);\r
+ typename MyMeshType::MyConnType interpolateMeshes(const MyMeshType& srcMesh, const MyMeshType& targetMesh, MatrixType& result, const std::string& method);\r
private:\r
SplittingPolicy _splitting_policy;\r
};\r
*
*/
template<class MyMeshType, class MatrixType>
- int Interpolation3D::interpolateMeshes(const MyMeshType& srcMesh, const MyMeshType& targetMesh, MatrixType& result, const std::string& method)
+ typename MyMeshType::MyConnType Interpolation3D::interpolateMeshes(const MyMeshType& srcMesh, const MyMeshType& targetMesh, MatrixType& result, const std::string& method)
{
typedef typename MyMeshType::MyConnType ConnType;
// create MeshElement objects corresponding to each element of the two meshes
std::vector<MeshElement<ConnType>*> srcElems(numSrcElems);
std::vector<MeshElement<ConnType>*> targetElems(numTargetElems);
- std::map<MeshElement<ConnType>*, int> indices;
+ std::map<MeshElement<ConnType>*, ConnType> indices;
for(ConnType i = 0 ; i < numSrcElems ; ++i)
srcElems[i] = new MeshElement<ConnType>(i, srcMesh);
MeshRegion<ConnType>& srcRegion = firstNode->getSrcRegion();
- for(unsigned long i = 0 ; i < numSrcElems ; ++i)
+ for(ConnType i = 0 ; i < numSrcElems ; ++i)
{
srcRegion.addElement(srcElems[i], srcMesh);
}
MeshRegion<ConnType>& targetRegion = firstNode->getTargetRegion();
- for(unsigned long i = 0 ; i < numTargetElems ; ++i)
+ for(ConnType i = 0 ; i < numTargetElems ; ++i)
{
if(!srcRegion.isDisjointWithElementBoundingBox( *(targetElems[i]) ))
{
// add source elements of current node that overlap the target regions of the new nodes
LOG(5, " -- Adding source elements");
- int numLeftElements = 0;
- int numRightElements = 0;
+ ConnType numLeftElements = 0;
+ ConnType numRightElements = 0;
for(typename std::vector<MeshElement<ConnType>*>::const_iterator iter = currNode->getSrcRegion().getBeginElements() ;
iter != currNode->getSrcRegion().getEndElements() ; ++iter)
{
// create BBTree structure
// - get bounding boxes
double* bboxes = new double[6 * numSrcElems];
- int* srcElemIdx = new int[numSrcElems];
+ ConnType* srcElemIdx = new ConnType[numSrcElems];
for(ConnType i = 0; i < numSrcElems ; ++i)
{
// get source bboxes in right order
for(ConnType i = 0; i < numTargetElems; ++i)
{
const BoundingBox* box = targetElems[i]->getBoundingBox();
- const int targetIdx = targetElems[i]->getIndex();
+ const ConnType targetIdx = targetElems[i]->getIndex();
// get target bbox in right order
double targetBox[6];
#endif
// free allocated memory
- int ret=intersector->getNumberOfColsOfResMatrix();
+ ConnType ret=intersector->getNumberOfColsOfResMatrix();
delete intersector;
Interpolation3D1D();\r
Interpolation3D1D(const InterpolationOptions& io);\r
template<class MyMeshType, class MatrixType>\r
- int interpolateMeshes(const MyMeshType& srcMesh, const MyMeshType& targetMesh, MatrixType& result, const std::string& method);\r
+ typename MyMeshType::MyConnType interpolateMeshes(const MyMeshType& srcMesh, const MyMeshType& targetMesh, MatrixType& result, const std::string& method);\r
private:\r
void adjustBoundingBoxes(std::vector<double>& bbox);\r
};\r
* adjusted in a similar fashion as in InterpolationPlanar::performAdjustmentOfBB()
**/
template<class MyMeshType, class MatrixType>
- int Interpolation3D1D::interpolateMeshes(const MyMeshType& srcMesh, const MyMeshType& targetMesh, MatrixType& result, const std::string& method)
+ typename MyMeshType::MyConnType Interpolation3D1D::interpolateMeshes(const MyMeshType& srcMesh, const MyMeshType& targetMesh, MatrixType& result, const std::string& method)
{
if(InterpolationOptions::getIntersectionType() != PointLocator)
INTERP_KERNEL::Exception("Invalid 3D/1D intersection type specified : must be PointLocator.");
std::vector<MeshElement<ConnType>*> srcElems(numSrcElems);
std::vector<MeshElement<ConnType>*> targetElems(numTargetElems);
- std::map<MeshElement<ConnType>*, int> indices;
+ std::map<MeshElement<ConnType>*, ConnType> indices;
for(ConnType i = 0 ; i < numSrcElems ; ++i)
srcElems[i] = new MeshElement<ConnType>(i, srcMesh);
// create BBTree structure
// - get bounding boxes
std::vector<double> bboxes(6*numSrcElems);
- int* srcElemIdx = new int[numSrcElems];
+ ConnType* srcElemIdx = new ConnType[numSrcElems];
for(ConnType i = 0; i < numSrcElems ; ++i)
{
// get source bboxes in right order
for(ConnType i = 0; i < numTargetElems; ++i)
{
const BoundingBox* box = targetElems[i]->getBoundingBox();
- const int targetIdx = targetElems[i]->getIndex();
+ const ConnType targetIdx = targetElems[i]->getIndex();
// get target bbox in right order
double targetBox[6];
// free allocated memory
delete [] srcElemIdx;
- int ret=intersector->getNumberOfColsOfResMatrix();
+ ConnType ret=intersector->getNumberOfColsOfResMatrix();
delete intersector;
//================================================================================
template<class MyCMeshType, class MyUMeshType, class MatrixType>
- int InterpolationCU::interpolateMeshes(const MyCMeshType& src_mesh,
+ ConnType InterpolationCU::interpolateMeshes(const MyCMeshType& src_mesh,
const MyUMeshType& tgt_mesh,
MatrixType& result,
const char * method)
}
// create empty maps for all target elements
result.resize( intersector->getNumberOfRowsOfResMatrix() );
- const int ret = intersector->getNumberOfColsOfResMatrix();
+ const ConnType ret = intersector->getNumberOfColsOfResMatrix();
const double* src_coords[ dim ];
- int src_nb_coords[ dim ];
- std::map< double, int> src_coord_to_index[ dim ];
+ ConnType src_nb_coords[ dim ];
+ std::map< double, ConnType> src_coord_to_index[ dim ];
for ( int j = 0; j < dim; ++j )
{
src_coords [j] = src_mesh.getCoordsAlongAxis( _TMIC( j ));
src_nb_coords[j] = static_cast<CConnType>(src_mesh.nbCellsAlongAxis ( _TMIC( j ))) + 1;
- for (int i = 0; i < src_nb_coords[j]; ++i )
+ for (ConnType i = 0; i < src_nb_coords[j]; ++i )
src_coord_to_index[j].insert( std::make_pair( src_coords[j][i], i ));
}
- const unsigned long tgtu_nb_cells = tgt_mesh.getNumberOfElements();
+ const ConnType tgtu_nb_cells = tgt_mesh.getNumberOfElements();
IntersectorCU<MyCMeshType, MyUMeshType, MatrixType> bbHelper(src_mesh, tgt_mesh);
double bb[2*dim];
// loop on unstructured tgt cells
- for(unsigned int iT=0; iT<tgtu_nb_cells; iT++)
+ for(ConnType iT=0; iT<tgtu_nb_cells; iT++)
{
result[ iT ].clear();
// find structured src cells intersecting iT cell
std::vector< std::vector< CConnType > > structIndices(1);
- std::map< double, int>::iterator coo_ind;
+ std::map< double, ConnType>::iterator coo_ind;
for ( int j = 0; j < dim; ++j )
{
coo_ind = src_coord_to_index[j].lower_bound( bb[2*j+1] - eps );
if ( coo_ind == src_coord_to_index[j].end() )
--coo_ind;
- int max_i = coo_ind->second;
+ ConnType max_i = coo_ind->second;
coo_ind = src_coord_to_index[j].upper_bound( bb[2*j ] + eps );
if ( coo_ind != src_coord_to_index[j].begin() )
--coo_ind;
- int min_i = coo_ind->second;
+ ConnType min_i = coo_ind->second;
std::vector< std::vector< CConnType > > newStructIndices;
for ( unsigned int iInd = 0; iInd < structIndices.size(); ++iInd )
{
- for ( int i = min_i; i < max_i; ++i )
+ for ( ConnType i = min_i; i < max_i; ++i )
{
std::vector< CConnType > index = structIndices[iInd];
index.push_back( i );
//================================================================================
template<class MyUMeshType, class MyCMeshType, class MatrixType>
- int InterpolationCU::interpolateMeshesRev(const MyUMeshType& meshS, const MyCMeshType& meshT, MatrixType& result, const char *method)
+ ConnType InterpolationCU::interpolateMeshesRev(const MyUMeshType& meshS, const MyCMeshType& meshT, MatrixType& result, const char *method)
{
MatrixType revResult;
- int sizeT = interpolateMeshes( meshT, meshS, revResult, method );
- int sizeS = revResult.size();
+ ConnType sizeT = interpolateMeshes( meshT, meshS, revResult, method );
+ ConnType sizeS = revResult.size();
result.resize( sizeT );
- for ( int iS = 0; iS < sizeS; ++iS )
+ for ( ConnType iS = 0; iS < sizeS; ++iS )
{
typename MatrixType::value_type & row = revResult[iS];
typename MatrixType::value_type::iterator iT_surf = row.begin();
}
template<int DIM, NumberingPolicy numPol, class MyMeshType>
- inline void getElemBB(double* bb, const double *coordsOfMesh, int iP, int nb_nodes)
+ inline void getElemBB(double* bb, const double *coordsOfMesh, mcIdType iP, int nb_nodes)
{
bb[0]=std::numeric_limits<double>::max();
bb[1]=-std::numeric_limits<double>::max();
}
}
-void OrientationInverterChecker::check(int *beginPt, int *endPt) const
+void OrientationInverterChecker::check(mcIdType *beginPt, mcIdType *endPt) const
{
if(std::distance(beginPt,endPt)!=getNbNodes())
{
}
}
-void OrientationInverterSEG2::operateAndShutUp(int *beginPt) const
+void OrientationInverterSEG2::operateAndShutUp(mcIdType *beginPt) const
{
std::swap(beginPt[0],beginPt[1]);
}
-void OrientationInverterSEG3::operateAndShutUp(int *beginPt) const
+void OrientationInverterSEG3::operateAndShutUp(mcIdType *beginPt) const
{
std::swap(beginPt[0],beginPt[2]);
}
-void OrientationInverter2DLinear::operateAndShutUp(int *beginPt) const
+void OrientationInverter2DLinear::operateAndShutUp(mcIdType *beginPt) const
{
std::reverse(beginPt+1,beginPt+getNbNodes());
}
-void OrientationInverter2DQuadratic::operateAndShutUp(int *beginPt) const
+void OrientationInverter2DQuadratic::operateAndShutUp(mcIdType *beginPt) const
{
int nbNodes(getNbNodes());
std::reverse(beginPt+1,beginPt+nbNodes/2);
std::reverse(beginPt+nbNodes/2,beginPt+nbNodes);
}
-void OrientationInverterPolygon::operate(int *beginPt, int *endPt) const
+void OrientationInverterPolygon::operate(mcIdType *beginPt, mcIdType *endPt) const
{
std::reverse(beginPt+1,endPt);
}
-void OrientationInverterQPolygon::operate(int *beginPt, int *endPt) const
+void OrientationInverterQPolygon::operate(mcIdType *beginPt, mcIdType *endPt) const
{
std::size_t sz(std::distance(beginPt,endPt));
std::reverse(beginPt+1,beginPt+sz/2);
std::reverse(beginPt+sz/2,endPt);
}
-void OrientationInverterTetra4::operateAndShutUp(int *beginPt) const
+void OrientationInverterTetra4::operateAndShutUp(mcIdType *beginPt) const
{
std::swap(beginPt[1],beginPt[2]);
}
-void OrientationInverterTetra10::operateAndShutUp(int *beginPt) const
+void OrientationInverterTetra10::operateAndShutUp(mcIdType *beginPt) const
{
std::swap(beginPt[1],beginPt[2]);
std::swap(beginPt[4],beginPt[6]);
std::swap(beginPt[8],beginPt[9]);
}
-void OrientationInverterPyra5::operateAndShutUp(int *beginPt) const
+void OrientationInverterPyra5::operateAndShutUp(mcIdType *beginPt) const
{
std::reverse(beginPt+1,beginPt+4);
}
-void OrientationInverterPyra13::operateAndShutUp(int *beginPt) const
+void OrientationInverterPyra13::operateAndShutUp(mcIdType *beginPt) const
{
std::reverse(beginPt+1,beginPt+4);
std::reverse(beginPt+5,beginPt+9);
std::swap(beginPt[10],beginPt[12]);
}
-void OrientationInverter3DExtrusionLinear::operateAndShutUp(int *beginPt) const
+void OrientationInverter3DExtrusionLinear::operateAndShutUp(mcIdType *beginPt) const
{
int nbNodes(getNbNodes());
std::reverse(beginPt+1,beginPt+nbNodes/2);
std::reverse(beginPt+nbNodes/2+1,beginPt+nbNodes);
}
-void OrientationInverter3DExtrusionQuadratic::operateAndShutUp(int *beginPt) const
+void OrientationInverter3DExtrusionQuadratic::operateAndShutUp(mcIdType *beginPt) const
{
int nbNodes(getNbNodes()),nbNodesLinearBase(nbNodes/5);
std::reverse(beginPt+1,beginPt+nbNodesLinearBase);
#include "INTERPKERNELDefines.hxx"
#include "NormalizedGeometricTypes"
+#include "MCIdType.hxx"
namespace INTERP_KERNEL
{
public:
INTERPKERNEL_EXPORT static OrientationInverter *BuildInstanceFrom(NormalizedCellType gt);
INTERPKERNEL_EXPORT virtual ~OrientationInverter() { }
- INTERPKERNEL_EXPORT virtual void operate(int *beginPt, int *endPt) const = 0;
+ INTERPKERNEL_EXPORT virtual void operate(mcIdType *beginPt, mcIdType *endPt) const = 0;
};
class OrientationInverterChecker : public OrientationInverter
{
public:
OrientationInverterChecker(unsigned nbNodes):_nb_nodes(nbNodes) { }
- void operate(int *beginPt, int *endPt) const { check(beginPt,endPt); operateAndShutUp(beginPt); }
- virtual void operateAndShutUp(int *beginPt) const = 0;
+ void operate(mcIdType *beginPt, mcIdType *endPt) const { check(beginPt,endPt); operateAndShutUp(beginPt); }
+ virtual void operateAndShutUp(mcIdType *beginPt) const = 0;
protected:
unsigned getNbNodes() const { return _nb_nodes; }
private:
- void check(int *beginPt, int *endPt) const;
+ void check(mcIdType *beginPt, mcIdType *endPt) const;
private:
unsigned _nb_nodes;
};
{
public:
OrientationInverterSEG2():OrientationInverterChecker(2u) { }
- void operateAndShutUp(int *beginPt) const;
+ void operateAndShutUp(mcIdType *beginPt) const;
};
class OrientationInverterSEG3 : public OrientationInverterChecker
{
public:
OrientationInverterSEG3():OrientationInverterChecker(3u) { }
- void operateAndShutUp(int *beginPt) const;
+ void operateAndShutUp(mcIdType *beginPt) const;
};
class OrientationInverter2DLinear : public OrientationInverterChecker
{
public:
OrientationInverter2DLinear(unsigned nbNodes):OrientationInverterChecker(nbNodes) { }
- void operateAndShutUp(int *beginPt) const;
+ void operateAndShutUp(mcIdType *beginPt) const;
};
class OrientationInverter2DQuadratic : public OrientationInverterChecker
{
public:
OrientationInverter2DQuadratic(unsigned nbNodes):OrientationInverterChecker(nbNodes) { }
- void operateAndShutUp(int *beginPt) const;
+ void operateAndShutUp(mcIdType *beginPt) const;
};
class OrientationInverterPolygon : public OrientationInverter
{
public:
- void operate(int *beginPt, int *endPt) const;
+ void operate(mcIdType *beginPt, mcIdType *endPt) const;
};
class OrientationInverterQPolygon : public OrientationInverter
{
public:
- void operate(int *beginPt, int *endPt) const;
+ void operate(mcIdType *beginPt, mcIdType *endPt) const;
};
class OrientationInverterTetra4 : public OrientationInverterChecker
{
public:
OrientationInverterTetra4():OrientationInverterChecker(4u) { }
- void operateAndShutUp(int *beginPt) const;
+ void operateAndShutUp(mcIdType *beginPt) const;
};
class OrientationInverterTetra10 : public OrientationInverterChecker
{
public:
OrientationInverterTetra10():OrientationInverterChecker(10u) { }
- void operateAndShutUp(int *beginPt) const;
+ void operateAndShutUp(mcIdType *beginPt) const;
};
class OrientationInverterPyra5 : public OrientationInverterChecker
{
public:
OrientationInverterPyra5():OrientationInverterChecker(5u) { }
- void operateAndShutUp(int *beginPt) const;
+ void operateAndShutUp(mcIdType *beginPt) const;
};
class OrientationInverterPyra13 : public OrientationInverterChecker
{
public:
OrientationInverterPyra13():OrientationInverterChecker(13u) { }
- void operateAndShutUp(int *beginPt) const;
+ void operateAndShutUp(mcIdType *beginPt) const;
};
class OrientationInverter3DExtrusionLinear : public OrientationInverterChecker
{
public:
OrientationInverter3DExtrusionLinear(unsigned nbNodes):OrientationInverterChecker(nbNodes) { }
- void operateAndShutUp(int *beginPt) const;
+ void operateAndShutUp(mcIdType *beginPt) const;
};
class OrientationInverter3DExtrusionQuadratic : public OrientationInverterChecker
{
public:
OrientationInverter3DExtrusionQuadratic(unsigned nbNodes):OrientationInverterChecker(nbNodes) { }
- void operateAndShutUp(int *beginPt) const;
+ void operateAndShutUp(mcIdType *beginPt) const;
};
}
static const int MESHDIM=MyMeshType::MY_MESHDIM;
typedef typename MyMeshType::MyConnType ConnType;
static const NumberingPolicy numPol=MyMeshType::My_numPol;
- typedef typename std::map<int,std::set<int> > DuplicateFacesType;
+ typedef typename std::map<ConnType,std::set<ConnType> > DuplicateFacesType;
public:
PlanarIntersector(const MyMeshType& meshT, const MyMeshType& meshS, double dimCaracteristic, double precision, double md3DSurf, double minDot3DSurf, double medianPlane, bool doRotate, int orientation, int printLevel);
virtual ~PlanarIntersector();
typedef typename MyMeshType::MyConnType ConnType;
const int SPACEDIM=MyMeshType::MY_SPACEDIM;
const NumberingPolicy numPol=MyMeshType::My_numPol;
- int nelem = _mesh.getNumberOfElements();
+ ConnType nelem = _mesh.getNumberOfElements();
_bb = new double[SPACEDIM*2*nelem];
const ConnType* conn = _mesh.getConnectivityPtr();
const ConnType* conn_index = _mesh.getConnectivityIndexPtr();
const double* coords=_mesh.getCoordinatesPtr();
- for (int i=0; i<nelem; i++)
+ for (ConnType i=0; i<nelem; i++)
{
for (int idim=0; idim<SPACEDIM; idim++)
{
_bb[2*(i*SPACEDIM+idim)]=std::numeric_limits<double>::max();
_bb[2*(i*SPACEDIM+idim)+1]=-std::numeric_limits<double>::max();
}
- for (int index= conn_index[i]; index < conn_index[i+1];index++)
+ for (ConnType index= conn_index[i]; index < conn_index[i+1];index++)
{
//coordelem points to the coordinates of the current node of the i-th element
const double* coordelem = coords+OTT<ConnType,numPol>::ind2C(conn[OTT<ConnType,numPol>::ind2C(index)])*SPACEDIM;
std::list<ConnType> retlist;
for(unsigned int i=0; i< candidates.size(); i++)
{
- int ielem=candidates[i];
+ ConnType ielem=candidates[i];
if (elementContainsPoint(ielem,x,eps))
retlist.push_back(OTT<ConnType,numPol>::indFC(ielem));
}
return ret;
}
- static bool isElementContainsPointAlg3D(const double *ptToTest, const typename MyMeshType::MyConnType *conn_elem, int conn_elem_sz, const double *coords, const CellModel& cmType, double eps)
+ static bool isElementContainsPointAlg3D(const double *ptToTest, const typename MyMeshType::MyConnType *conn_elem, typename MyMeshType::MyConnType conn_elem_sz, const double *coords, const CellModel& cmType, double eps)
{
const int SPACEDIM=MyMeshType::MY_SPACEDIM;
typedef typename MyMeshType::MyConnType ConnType;
/*!
* Precondition : spacedim==meshdim. To be checked upstream to this call.
*/
- static bool isElementContainsPoint(const double *ptToTest, NormalizedCellType type, const double *coords, const typename MyMeshType::MyConnType *conn_elem, int conn_elem_sz, double eps)
+ static bool isElementContainsPoint(const double *ptToTest, NormalizedCellType type, const double *coords, const typename MyMeshType::MyConnType *conn_elem, typename MyMeshType::MyConnType conn_elem_sz, double eps)
{
const int SPACEDIM=MyMeshType::MY_SPACEDIM;
typedef typename MyMeshType::MyConnType ConnType;
*/
//================================================================================
- virtual std::list<int> locates(const double* x, double eps)
+ virtual std::list<typename MyMeshType::MyConnType> locates(const double* x, double eps)
{
typedef typename MyMeshType::MyConnType ConnType;
const NumberingPolicy numPol=MyMeshType::My_numPol;
- std::list<int> simplexNodes;
- std::list<int> candidates = PointLocatorAlgos<MyMeshType>::locates(x,eps);
- std::list<int>::iterator eIt = candidates.begin();
+ std::list<ConnType> simplexNodes;
+ std::list<ConnType> candidates = PointLocatorAlgos<MyMeshType>::locates(x,eps);
+ typename std::list<ConnType>::iterator eIt = candidates.begin();
for ( ; eIt != candidates.end(); ++eIt )
{
- const int i = OTT<ConnType,numPol>::ind2C( *eIt );
+ const ConnType i = OTT<ConnType,numPol>::ind2C( *eIt );
const double* coords= _mesh.getCoordinatesPtr();
const ConnType* conn=_mesh.getConnectivityPtr();
const ConnType* conn_index= _mesh.getConnectivityIndexPtr();
else
{
NormalizedCellType simlexType = cell.getDimension()==3 ? NORM_TETRA4 : NORM_TRI3;
- std::vector<int> sonNodes;
+ std::vector<mcIdType> sonNodes;
NormalizedCellType sonType;
const unsigned nbSons = cell.getNumberOfSons2( conn_elem, conn_elem_sz );
for ( unsigned s = 0; s < nbSons; ++s )
{
sonNodes.resize( cell.getNumberOfNodesConstituentTheSon2( s, conn_elem, conn_elem_sz ));
cell.fillSonCellNodalConnectivity2( s, conn_elem, conn_elem_sz, &sonNodes[0], sonType );
- std::set<int> sonNodesSet( sonNodes.begin(), sonNodes.end() );
+ std::set<mcIdType> sonNodesSet( sonNodes.begin(), sonNodes.end() );
std::set< std::set< ConnType > > checkedSonSimplex;
for ( unsigned sn = 0; sn < sonNodes.size(); ++sn )
#include "InterpKernelException.hxx"
#include "InterpKernelHashMap.hxx"
#include "VectorUtils.hxx"
+#include "MCIdType.hxx"
#include <functional>
#include <vector>
-15,-19,-18,-10,-7,-17,-12,7,
-19,-16,-11,-18,-17,-8,6,-12};
- void SplitHexa8IntoTetras(SplittingPolicy policy, const int *nodalConnBg, const int *nodalConnEnd, const double *coords,
- std::vector<int>& tetrasNodalConn, std::vector<double>& addCoords);
+ void SplitHexa8IntoTetras(SplittingPolicy policy, const mcIdType *nodalConnBg, const mcIdType *nodalConnEnd, const double *coords,
+ std::vector<mcIdType>& tetrasNodalConn, std::vector<double>& addCoords);
- INTERPKERNEL_EXPORT void SplitIntoTetras(SplittingPolicy policy, NormalizedCellType gt, const int *nodalConnBg, const int *nodalConnEnd, const double *coords,
- std::vector<int>& tetrasNodalConn, std::vector<double>& addCoords);
+ INTERPKERNEL_EXPORT void SplitIntoTetras(SplittingPolicy policy, NormalizedCellType gt, const mcIdType *nodalConnBg, const mcIdType *nodalConnEnd, const double *coords,
+ std::vector<mcIdType>& tetrasNodalConn, std::vector<double>& addCoords);
/**
* \brief Class representing a triangular face, used as key in caching hash map in SplitterTetra.
* @param node2 global number of the second node of the face
* @param node3 global number of the third node of the face
*/
- TriangleFaceKey(int node1, int node2, int node3)
+ TriangleFaceKey(mcIdType node1, mcIdType node2, mcIdType node3)
{
Sort3Ints(_nodes, node1, node2, node3);
_hashVal = ( _nodes[0] + _nodes[1] + _nodes[2] ) % 29;
return _hashVal;
}
- inline static void Sort3Ints(int* sorted, int node1, int node2, int node3);
+ inline static void Sort3Ints(mcIdType* sorted, mcIdType node1, mcIdType node2, mcIdType node3);
private:
/// global numbers of the three nodes, sorted in ascending order
- int _nodes[3];
+ mcIdType _nodes[3];
/// hash value for the object, calculated in the constructor
int _hashVal;
/**
* Method to sort three integers in ascending order
*
- * @param sorted int[3] array in which to store the result
+ * @param sorted mcIdType[3] array in which to store the result
* @param x1 first integer
* @param x2 second integer
* @param x3 third integer
*/
- inline void TriangleFaceKey::Sort3Ints(int* sorted, int x1, int x2, int x3)
+ inline void TriangleFaceKey::Sort3Ints(mcIdType* sorted, mcIdType x1, mcIdType x2, mcIdType x3)
{
if(x1 < x2)
{
double intersectSourceCell(typename MyMeshType::MyConnType srcCell, double* baryCentre=0);
double intersectSourceFace(const NormalizedCellType polyType,
const int polyNodesNbr,
- const int *const polyNodes,
+ const mcIdType *const polyNodes,
const double *const *const polyCoords,
const double dimCaracteristic,
const double precision,
double intersectTetra(const double** tetraCorners);
- typename MyMeshType::MyConnType getId(int id) { return _conn[id]; }
+ typename MyMeshType::MyConnType getId(mcIdType id) { return _conn[id]; }
void splitIntoDualCells(SplitterTetra<MyMeshType> **output);
TetraAffineTransform* _t;
/// HashMap relating node numbers to transformed nodes, used for caching
- HashMap< int , double* > _nodes;
+ HashMap< typename MyMeshType::MyConnType , double* > _nodes;
/// HashMap relating triangular faces to calculated volume contributions, used for caching
HashMap< TriangleFaceKey, double > _volumes;
bool isTargetOutside = false;
// calculate the coordinates of the nodes
- int *cellNodes=new int[nbOfNodes4Type];
+ ConnType *cellNodes=new ConnType[nbOfNodes4Type];
for(int i = 0;i<(int)nbOfNodes4Type;++i)
{
// we could store mapping local -> global numbers too, but not sure it is worth it
- const int globalNodeNum = getGlobalNumberOfNode(i, OTT<ConnType,numPol>::indFC(element), _src_mesh);
+ const ConnType globalNodeNum = getGlobalNumberOfNode(i, OTT<ConnType,numPol>::indFC(element), _src_mesh);
cellNodes[i]=globalNodeNum;
if(_nodes.find(globalNodeNum) == _nodes.end())
{
{
// get sons connectivity
NormalizedCellType faceType;
- int *faceNodes, nbFaceNodes=-1;
+ mcIdType *faceNodes, nbFaceNodes=-1;
if ( cellModelCell.isDynamic() )
{
- faceNodes=new int[nbOfNodes4Type];
+ faceNodes=new mcIdType[nbOfNodes4Type];
nbFaceNodes = cellModelCell.fillSonCellNodalConnectivity2(ii,rawCellConn,rawNbCellNodes,faceNodes,faceType);
for ( int i = 0; i < nbFaceNodes; ++i )
faceNodes[i] = OTT<ConnType,numPol>::coo2C(faceNodes[i]);
const CellModel& faceModel=CellModel::GetCellModel(faceType);
assert(faceModel.getDimension() == 2);
nbFaceNodes = cellModelCell.getNumberOfNodesConstituentTheSon(ii);
- faceNodes = new int[nbFaceNodes];
+ faceNodes = new ConnType[nbFaceNodes];
cellModelCell.fillSonCellNodalConnectivity(ii,cellNodes,faceNodes);
}
// intersect a son with the unit tetra
template<class MyMeshType>
double SplitterTetra<MyMeshType>::intersectSourceFace(const NormalizedCellType polyType,
const int polyNodesNbr,
- const int *const polyNodes,
+ const mcIdType *const polyNodes,
const double *const *const polyCoords,
const double dimCaracteristic,
const double precision,
if(!isTargetOutside)
{
const CellModel& cellModelCell=CellModel::GetCellModel(NORM_TETRA4);
- int cellNodes[4] = { 0, 1, 2, 3 }, faceNodes[3];
+ mcIdType cellNodes[4] = { 0, 1, 2, 3 }, faceNodes[3];
for(unsigned ii = 0 ; ii < 4 ; ++ii)
{
*/
virtual void intersectCells(ConnType targetCell, const std::vector<ConnType>& srcCells, MyMatrix& res) = 0;
- virtual int getNumberOfRowsOfResMatrix() const = 0;
- virtual int getNumberOfColsOfResMatrix() const = 0;
+ virtual ConnType getNumberOfRowsOfResMatrix() const = 0;
+ virtual ConnType getNumberOfColsOfResMatrix() const = 0;
virtual ~TargetIntersector() { }
};
}
#include "INTERPKERNELDefines.hxx"
#include "InterpKernelException.hxx"
#include "NormalizedUnstructuredMesh.hxx"
+#include "MCIdType.hxx"
namespace INTERP_KERNEL
{
double INTERPKERNEL_EXPORT DistanceFromPtToTriInSpaceDim3(const double *pt, const double *pt0Tri3, const double *pt1Tri3, const double *pt2Tri3);
- double INTERPKERNEL_EXPORT DistanceFromPtToPolygonInSpaceDim3(const double *pt, const int *connOfPolygonBg, const int *connOfPolygonEnd, const double *coords);
+ double INTERPKERNEL_EXPORT DistanceFromPtToPolygonInSpaceDim3(const double *pt, const mcIdType *connOfPolygonBg, const mcIdType *connOfPolygonEnd, const double *coords);
bool ComputeRotTranslationMatrixToPut3PointsOnOXY(const double *pt0Tri3, const double *pt1Tri3, const double *pt2Tri3, double *matrix);
}
case INTERP_KERNEL::NORM_SEG2 :
case INTERP_KERNEL::NORM_SEG4 :
{
- int N1 = OTT<ConnType,numPol>::coo2C(connec[0]);
- int N2 = OTT<ConnType,numPol>::coo2C(connec[1]);
+ ConnType N1 = OTT<ConnType,numPol>::coo2C(connec[0]);
+ ConnType N2 = OTT<ConnType,numPol>::coo2C(connec[1]);
return INTERP_KERNEL::calculateLgthForSeg2(coords+(SPACEDIM*N1),coords+(SPACEDIM*N2),SPACEDIM);
}
case INTERP_KERNEL::NORM_SEG3 :
{
- int beginNode = OTT<ConnType,numPol>::coo2C(connec[0]);
- int endNode = OTT<ConnType,numPol>::coo2C(connec[1]);
- int middleNode = OTT<ConnType,numPol>::coo2C(connec[2]);
+ ConnType beginNode = OTT<ConnType,numPol>::coo2C(connec[0]);
+ ConnType endNode = OTT<ConnType,numPol>::coo2C(connec[1]);
+ ConnType middleNode = OTT<ConnType,numPol>::coo2C(connec[2]);
return INTERP_KERNEL::calculateLgthForSeg3(coords+(SPACEDIM*beginNode),coords+(SPACEDIM*endNode),coords+(SPACEDIM*middleNode),SPACEDIM);
}
case INTERP_KERNEL::NORM_TRI3 :
{
- int N1 = OTT<ConnType,numPol>::coo2C(connec[0]);
- int N2 = OTT<ConnType,numPol>::coo2C(connec[1]);
- int N3 = OTT<ConnType,numPol>::coo2C(connec[2]);
+ ConnType N1 = OTT<ConnType,numPol>::coo2C(connec[0]);
+ ConnType N2 = OTT<ConnType,numPol>::coo2C(connec[1]);
+ ConnType N3 = OTT<ConnType,numPol>::coo2C(connec[2]);
return INTERP_KERNEL::calculateAreaForTria(coords+(SPACEDIM*N1),
coords+(SPACEDIM*N2),
break;
case INTERP_KERNEL::NORM_QUAD4 :
{
- int N1 = OTT<ConnType,numPol>::coo2C(connec[0]);
- int N2 = OTT<ConnType,numPol>::coo2C(connec[1]);
- int N3 = OTT<ConnType,numPol>::coo2C(connec[2]);
- int N4 = OTT<ConnType,numPol>::coo2C(connec[3]);
+ ConnType N1 = OTT<ConnType,numPol>::coo2C(connec[0]);
+ ConnType N2 = OTT<ConnType,numPol>::coo2C(connec[1]);
+ ConnType N3 = OTT<ConnType,numPol>::coo2C(connec[2]);
+ ConnType N4 = OTT<ConnType,numPol>::coo2C(connec[3]);
return INTERP_KERNEL::calculateAreaForQuad(coords+SPACEDIM*N1,
coords+SPACEDIM*N2,
case INTERP_KERNEL::NORM_TETRA4 :
case INTERP_KERNEL::NORM_TETRA10 :
{
- int N1 = OTT<ConnType,numPol>::coo2C(connec[0]);
- int N2 = OTT<ConnType,numPol>::coo2C(connec[1]);
- int N3 = OTT<ConnType,numPol>::coo2C(connec[2]);
- int N4 = OTT<ConnType,numPol>::coo2C(connec[3]);
+ ConnType N1 = OTT<ConnType,numPol>::coo2C(connec[0]);
+ ConnType N2 = OTT<ConnType,numPol>::coo2C(connec[1]);
+ ConnType N3 = OTT<ConnType,numPol>::coo2C(connec[2]);
+ ConnType N4 = OTT<ConnType,numPol>::coo2C(connec[3]);
return INTERP_KERNEL::calculateVolumeForTetra(coords+SPACEDIM*N1,
coords+SPACEDIM*N2,
case INTERP_KERNEL::NORM_PYRA5 :
case INTERP_KERNEL::NORM_PYRA13 :
{
- int N1 = OTT<ConnType,numPol>::coo2C(connec[0]);
- int N2 = OTT<ConnType,numPol>::coo2C(connec[1]);
- int N3 = OTT<ConnType,numPol>::coo2C(connec[2]);
- int N4 = OTT<ConnType,numPol>::coo2C(connec[3]);
- int N5 = OTT<ConnType,numPol>::coo2C(connec[4]);
+ ConnType N1 = OTT<ConnType,numPol>::coo2C(connec[0]);
+ ConnType N2 = OTT<ConnType,numPol>::coo2C(connec[1]);
+ ConnType N3 = OTT<ConnType,numPol>::coo2C(connec[2]);
+ ConnType N4 = OTT<ConnType,numPol>::coo2C(connec[3]);
+ ConnType N5 = OTT<ConnType,numPol>::coo2C(connec[4]);
return INTERP_KERNEL::calculateVolumeForPyra(coords+SPACEDIM*N1,
coords+SPACEDIM*N2,
case INTERP_KERNEL::NORM_PENTA15 :
case INTERP_KERNEL::NORM_PENTA18 :
{
- int N1 = OTT<ConnType,numPol>::coo2C(connec[0]);
- int N2 = OTT<ConnType,numPol>::coo2C(connec[1]);
- int N3 = OTT<ConnType,numPol>::coo2C(connec[2]);
- int N4 = OTT<ConnType,numPol>::coo2C(connec[3]);
- int N5 = OTT<ConnType,numPol>::coo2C(connec[4]);
- int N6 = OTT<ConnType,numPol>::coo2C(connec[5]);
+ ConnType N1 = OTT<ConnType,numPol>::coo2C(connec[0]);
+ ConnType N2 = OTT<ConnType,numPol>::coo2C(connec[1]);
+ ConnType N3 = OTT<ConnType,numPol>::coo2C(connec[2]);
+ ConnType N4 = OTT<ConnType,numPol>::coo2C(connec[3]);
+ ConnType N5 = OTT<ConnType,numPol>::coo2C(connec[4]);
+ ConnType N6 = OTT<ConnType,numPol>::coo2C(connec[5]);
return INTERP_KERNEL::calculateVolumeForPenta(coords+SPACEDIM*N1,
coords+SPACEDIM*N2,
case INTERP_KERNEL::NORM_HEXA20 :
case INTERP_KERNEL::NORM_HEXA27 :
{
- int N1 = OTT<ConnType,numPol>::coo2C(connec[0]);
- int N2 = OTT<ConnType,numPol>::coo2C(connec[1]);
- int N3 = OTT<ConnType,numPol>::coo2C(connec[2]);
- int N4 = OTT<ConnType,numPol>::coo2C(connec[3]);
- int N5 = OTT<ConnType,numPol>::coo2C(connec[4]);
- int N6 = OTT<ConnType,numPol>::coo2C(connec[5]);
- int N7 = OTT<ConnType,numPol>::coo2C(connec[6]);
- int N8 = OTT<ConnType,numPol>::coo2C(connec[7]);
+ ConnType N1 = OTT<ConnType,numPol>::coo2C(connec[0]);
+ ConnType N2 = OTT<ConnType,numPol>::coo2C(connec[1]);
+ ConnType N3 = OTT<ConnType,numPol>::coo2C(connec[2]);
+ ConnType N4 = OTT<ConnType,numPol>::coo2C(connec[3]);
+ ConnType N5 = OTT<ConnType,numPol>::coo2C(connec[4]);
+ ConnType N6 = OTT<ConnType,numPol>::coo2C(connec[5]);
+ ConnType N7 = OTT<ConnType,numPol>::coo2C(connec[6]);
+ ConnType N8 = OTT<ConnType,numPol>::coo2C(connec[7]);
return INTERP_KERNEL::calculateVolumeForHexa(coords+SPACEDIM*N1,
coords+SPACEDIM*N2,
break;
case INTERP_KERNEL::NORM_HEXGP12:
{
- const int connecHexa12[43]={
+ const ConnType connecHexa12[43]={
OTT<ConnType,numPol>::coo2C(connec[0]),OTT<ConnType,numPol>::coo2C(connec[1]),OTT<ConnType,numPol>::coo2C(connec[2]),OTT<ConnType,numPol>::coo2C(connec[3]),OTT<ConnType,numPol>::coo2C(connec[4]),OTT<ConnType,numPol>::coo2C(connec[5]),-1,
OTT<ConnType,numPol>::coo2C(connec[6]),OTT<ConnType,numPol>::coo2C(connec[11]),OTT<ConnType,numPol>::coo2C(connec[10]),OTT<ConnType,numPol>::coo2C(connec[9]),OTT<ConnType,numPol>::coo2C(connec[8]),OTT<ConnType,numPol>::coo2C(connec[7]),-1,
OTT<ConnType,numPol>::coo2C(connec[0]),OTT<ConnType,numPol>::coo2C(connec[6]),OTT<ConnType,numPol>::coo2C(connec[7]),OTT<ConnType,numPol>::coo2C(connec[1]),-1,
}
case NORM_HEXA8:
{
- const int conn[29]={
+ const ConnType conn[29]={
OTT<ConnType,numPol>::coo2C(connec[0]),OTT<ConnType,numPol>::coo2C(connec[1]),OTT<ConnType,numPol>::coo2C(connec[2]),OTT<ConnType,numPol>::coo2C(connec[3]),-1,
OTT<ConnType,numPol>::coo2C(connec[4]),OTT<ConnType,numPol>::coo2C(connec[7]),OTT<ConnType,numPol>::coo2C(connec[6]),OTT<ConnType,numPol>::coo2C(connec[5]),-1,
OTT<ConnType,numPol>::coo2C(connec[0]),OTT<ConnType,numPol>::coo2C(connec[3]),OTT<ConnType,numPol>::coo2C(connec[7]),OTT<ConnType,numPol>::coo2C(connec[4]),-1,
}
case NORM_PENTA6:
{
- const int conn[22]={
+ const ConnType conn[22]={
OTT<ConnType,numPol>::coo2C(connec[0]),OTT<ConnType,numPol>::coo2C(connec[1]),OTT<ConnType,numPol>::coo2C(connec[2]),-1,
OTT<ConnType,numPol>::coo2C(connec[3]),OTT<ConnType,numPol>::coo2C(connec[5]),OTT<ConnType,numPol>::coo2C(connec[4]),-1,
OTT<ConnType,numPol>::coo2C(connec[0]),OTT<ConnType,numPol>::coo2C(connec[2]),OTT<ConnType,numPol>::coo2C(connec[5]),OTT<ConnType,numPol>::coo2C(connec[3]),-1,
}
case INTERP_KERNEL::NORM_HEXGP12:
{
- const int connecHexa12[43]={
+ const ConnType connecHexa12[43]={
OTT<ConnType,numPol>::coo2C(connec[0]),OTT<ConnType,numPol>::coo2C(connec[1]),OTT<ConnType,numPol>::coo2C(connec[2]),OTT<ConnType,numPol>::coo2C(connec[3]),OTT<ConnType,numPol>::coo2C(connec[4]),OTT<ConnType,numPol>::coo2C(connec[5]),-1,
OTT<ConnType,numPol>::coo2C(connec[6]),OTT<ConnType,numPol>::coo2C(connec[11]),OTT<ConnType,numPol>::coo2C(connec[10]),OTT<ConnType,numPol>::coo2C(connec[9]),OTT<ConnType,numPol>::coo2C(connec[8]),OTT<ConnType,numPol>::coo2C(connec[7]),-1,
OTT<ConnType,numPol>::coo2C(connec[0]),OTT<ConnType,numPol>::coo2C(connec[6]),OTT<ConnType,numPol>::coo2C(connec[7]),OTT<ConnType,numPol>::coo2C(connec[1]),-1,
