X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FMEDCoupling_Swig%2FMEDCouplingCommon.i;h=b6d35cfe6820a0c71fb0ff392bc1363d70fea865;hb=f2ab61e92f55ee52cf5196f7904f625d93c8c2d0;hp=dbe258008f430a3185f773d48cf9ff9a5daf9964;hpb=4e3de127a60f9ffb63abae1d17ed01f3f6711fd2;p=tools%2Fmedcoupling.git diff --git a/src/MEDCoupling_Swig/MEDCouplingCommon.i b/src/MEDCoupling_Swig/MEDCouplingCommon.i index dbe258008..b6d35cfe6 100644 --- a/src/MEDCoupling_Swig/MEDCouplingCommon.i +++ b/src/MEDCoupling_Swig/MEDCouplingCommon.i @@ -1,4 +1,4 @@ -// Copyright (C) 2017-2019 CEA/DEN, EDF R&D +// Copyright (C) 2017-2020 CEA/DEN, EDF R&D // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public @@ -27,6 +27,7 @@ %{ #include "MEDCouplingMemArray.hxx" +#include "MEDCouplingMemArray.txx" #include "MEDCouplingUMesh.hxx" #include "MEDCouplingMappedExtrudedMesh.hxx" #include "MEDCouplingCMesh.hxx" @@ -36,7 +37,8 @@ #include "MEDCoupling1GTUMesh.hxx" #include "MEDCouplingField.hxx" #include "MEDCouplingFieldDouble.hxx" -#include "MEDCouplingFieldInt.hxx" +#include "MEDCouplingFieldInt32.hxx" +#include "MEDCouplingFieldInt64.hxx" #include "MEDCouplingFieldFloat.hxx" #include "MEDCouplingFieldTemplate.hxx" #include "MEDCouplingGaussLocalization.hxx" @@ -60,10 +62,31 @@ using namespace INTERP_KERNEL; %} -%template(ivec) std::vector; %template(dvec) std::vector; %template(svec) std::vector; +//%include stdint.i + +#ifndef MEDCOUPLING_USE_64BIT_IDS +//typedef std::int32_t mcIdType; +typedef int mcIdType; +typedef DataArrayInt32 DataArrayIdType; +%template(ivec) std::vector; +%template(i64vec) std::vector; +#else +//typedef std::int64_t mcIdType; +typedef DataArrayInt64 DataArrayIdType; +#ifdef WIN32 +%template(ivec) std::vector; +typedef long long mcIdType; +#else +%template(ivec) std::vector; +typedef long int mcIdType; +#endif +%template(i32vec) std::vector; +#endif + + //////////////////// %typemap(out) MEDCoupling::MEDCouplingMesh* { @@ -248,15 +271,24 @@ using namespace INTERP_KERNEL; %newobject MEDCoupling::MEDCouplingFieldDouble::cellToNodeDiscretization; %newobject MEDCoupling::MEDCouplingFieldDouble::getValueOnMulti; %newobject MEDCoupling::MEDCouplingFieldDouble::computeVectorFieldCyl; -%newobject MEDCoupling::MEDCouplingFieldInt::New; -%newobject MEDCoupling::MEDCouplingFieldInt::convertToDblField; -%newobject MEDCoupling::MEDCouplingFieldInt::getArray; -%newobject MEDCoupling::MEDCouplingFieldInt::deepCopy; -%newobject MEDCoupling::MEDCouplingFieldInt::clone; -%newobject MEDCoupling::MEDCouplingFieldInt::cloneWithMesh; -%newobject MEDCoupling::MEDCouplingFieldInt::buildSubPart; -%newobject MEDCoupling::MEDCouplingFieldInt::buildSubPartRange; -%newobject MEDCoupling::MEDCouplingFieldInt::__getitem__; +%newobject MEDCoupling::MEDCouplingFieldInt32::New; +%newobject MEDCoupling::MEDCouplingFieldInt32::convertToDblField; +%newobject MEDCoupling::MEDCouplingFieldInt32::getArray; +%newobject MEDCoupling::MEDCouplingFieldInt32::deepCopy; +%newobject MEDCoupling::MEDCouplingFieldInt32::clone; +%newobject MEDCoupling::MEDCouplingFieldInt32::cloneWithMesh; +%newobject MEDCoupling::MEDCouplingFieldInt32::buildSubPart; +%newobject MEDCoupling::MEDCouplingFieldInt32::buildSubPartRange; +%newobject MEDCoupling::MEDCouplingFieldInt32::__getitem__; +%newobject MEDCoupling::MEDCouplingFieldInt64::New; +%newobject MEDCoupling::MEDCouplingFieldInt64::convertToDblField; +%newobject MEDCoupling::MEDCouplingFieldInt64::getArray; +%newobject MEDCoupling::MEDCouplingFieldInt64::deepCopy; +%newobject MEDCoupling::MEDCouplingFieldInt64::clone; +%newobject MEDCoupling::MEDCouplingFieldInt64::cloneWithMesh; +%newobject MEDCoupling::MEDCouplingFieldInt64::buildSubPart; +%newobject MEDCoupling::MEDCouplingFieldInt64::buildSubPartRange; +%newobject MEDCoupling::MEDCouplingFieldInt64::__getitem__; %newobject MEDCoupling::MEDCouplingFieldFloat::New; %newobject MEDCoupling::MEDCouplingFieldFloat::convertToDblField; %newobject MEDCoupling::MEDCouplingFieldFloat::getArray; @@ -444,6 +476,10 @@ using namespace INTERP_KERNEL; %newobject MEDCoupling::MEDCouplingSkyLineArray::getSuperIndexArray; %newobject MEDCoupling::MEDCouplingSkyLineArray::getIndexArray; %newobject MEDCoupling::MEDCouplingSkyLineArray::getValuesArray; +%newobject MEDCoupling::MEDCouplingSkyLineArray::groupPacks; +%newobject MEDCoupling::MEDCouplingSkyLineArray::uniqueNotSortedByPack; +%newobject MEDCoupling::MEDCouplingSkyLineArray::AggregatePacks; +%newobject MEDCoupling::MEDCouplingSkyLineArray::deepCopy; %feature("unref") MEDCouplingPointSet "$this->decrRef();" %feature("unref") MEDCouplingMesh "$this->decrRef();" @@ -463,7 +499,8 @@ using namespace INTERP_KERNEL; %feature("unref") MEDCouplingFieldDiscretizationKriging "$this->decrRef();" %feature("unref") MEDCouplingFieldDouble "$this->decrRef();" %feature("unref") MEDCouplingFieldFloat "$this->decrRef();" -%feature("unref") MEDCouplingFieldInt "$this->decrRef();" +%feature("unref") MEDCouplingFieldInt32 "$this->decrRef();" +%feature("unref") MEDCouplingFieldInt64 "$this->decrRef();" %feature("unref") MEDCouplingMultiFields "$this->decrRef();" %feature("unref") MEDCouplingFieldTemplate "$this->decrRef();" %feature("unref") MEDCouplingMultiFields "$this->decrRef();" @@ -499,13 +536,59 @@ using namespace INTERP_KERNEL; {// AGY : here initialization of C++ traits in MEDCouplingDataArrayTypemaps.i for code factorization. Awful, I know, but no other solutions. SWIGTITraits::TI=SWIGTYPE_p_MEDCoupling__DataArrayDouble; SWIGTITraits::TI=SWIGTYPE_p_MEDCoupling__DataArrayFloat; - SWIGTITraits::TI=SWIGTYPE_p_MEDCoupling__DataArrayInt; + SWIGTITraits::TI=SWIGTYPE_p_MEDCoupling__DataArrayInt32; + SWIGTITraits::TI=SWIGTYPE_p_MEDCoupling__DataArrayInt64; SWIGTITraits::TI_TUPLE=SWIGTYPE_p_MEDCoupling__DataArrayDoubleTuple; SWIGTITraits::TI_TUPLE=SWIGTYPE_p_MEDCoupling__DataArrayFloatTuple; - SWIGTITraits::TI_TUPLE=SWIGTYPE_p_MEDCoupling__DataArrayIntTuple; + SWIGTITraits::TI_TUPLE=SWIGTYPE_p_MEDCoupling__DataArrayInt32Tuple; + SWIGTITraits::TI_TUPLE=SWIGTYPE_p_MEDCoupling__DataArrayInt64Tuple; } %} +%inline +{ + PyObject *med2vtk_cell_types() + { + Py_ssize_t sz(sizeof(MEDCOUPLING2VTKTYPETRADUCER)/sizeof(decltype(MEDCOUPLING2VTKTYPETRADUCER[0]))); + PyObject *ret(PyList_New(sz)); + for(Py_ssize_t i=0;i retCpp(szOut,-1); + mcIdType id(0); + for(const unsigned char *it=MEDCOUPLING2VTKTYPETRADUCER;it!=MEDCOUPLING2VTKTYPETRADUCER+sz;it++,id++) + { + if(*it!=MEDCOUPLING2VTKTYPETRADUCER_NONE) + retCpp[*it]=id; + } + // + PyObject *ret(PyList_New(szOut)); + id = 0; + for(auto it=retCpp.begin();it!=retCpp.end();it++,id++) + PyList_SetItem(ret,id,PyInt_FromLong(*it)); + return ret; + } + + PyObject *AllGeometricTypes() + { + Py_ssize_t sz(MEDCouplingUMesh::N_MEDMEM_ORDER); + PyObject *ret(PyList_New(sz)); + for(Py_ssize_t i=0;i& tinyInfoD, const std::vector& tinyInfo, const DataArrayInt *a1, DataArrayDouble *a2, const std::vector& littleStrings); + virtual DataArrayIdType *simplexize(int policy); + virtual void unserialization(const std::vector& tinyInfoD, const std::vector& tinyInfo, const DataArrayIdType *a1, DataArrayDouble *a2, const std::vector& littleStrings); static MEDCouplingMesh *MergeMeshes(const MEDCouplingMesh *mesh1, const MEDCouplingMesh *mesh2); static bool IsStaticGeometricType(INTERP_KERNEL::NormalizedCellType type); static bool IsLinearGeometricType(INTERP_KERNEL::NormalizedCellType type); @@ -687,13 +771,13 @@ namespace MEDCoupling return ret2; } - int getCellContainingPoint(PyObject *p, double eps) const + mcIdType getCellContainingPoint(PyObject *p, double eps) const { double val; DataArrayDouble *a; DataArrayDoubleTuple *aa; std::vector bb; - int sw; + mcIdType sw; int spaceDim=self->getSpaceDimension(); const char msg[]="Python wrap of MEDCouplingMesh::getCellContainingPoint : "; const double *pos=convertObjToPossibleCpp5_Safe(p,sw,val,a,aa,bb,msg,1,spaceDim,true); @@ -706,15 +790,15 @@ namespace MEDCoupling DataArrayDouble *a; DataArrayDoubleTuple *aa; std::vector bb; - int sw; + mcIdType sw; int spaceDim=self->getSpaceDimension(); const char msg[]="Python wrap of MEDCouplingMesh::getCellsContainingPoint : "; const double *pos=convertObjToPossibleCpp5_Safe(p,sw,val,a,aa,bb,msg,nbOfPoints,spaceDim,true); - MCAuto elts,eltsIndex; + MCAuto elts,eltsIndex; self->getCellsContainingPoints(pos,nbOfPoints,eps,elts,eltsIndex); PyObject *ret=PyTuple_New(2); - PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(elts.retn()),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(eltsIndex.retn()),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(elts.retn()),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(eltsIndex.retn()),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); return ret; } @@ -724,27 +808,27 @@ namespace MEDCoupling DataArrayDouble *a; DataArrayDoubleTuple *aa; std::vector bb; - int sw; + mcIdType sw; int spaceDim=self->getSpaceDimension(); const char msg[]="Python wrap of MEDCouplingMesh::getCellsContainingPointsLinearPartOnlyOnNonDynType : "; const double *pos=convertObjToPossibleCpp5_Safe(p,sw,val,a,aa,bb,msg,nbOfPoints,spaceDim,true); - MCAuto elts,eltsIndex; + MCAuto elts,eltsIndex; self->getCellsContainingPointsLinearPartOnlyOnNonDynType(pos,nbOfPoints,eps,elts,eltsIndex); PyObject *ret=PyTuple_New(2); - PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(elts.retn()),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(eltsIndex.retn()),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(elts.retn()),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(eltsIndex.retn()),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); return ret; } PyObject *getCellsContainingPoints(PyObject *p, double eps) const { - auto getCellsContainingPointsFunc=[self](const double *a, int b,double c, MCAuto& d, MCAuto& e) { self->getCellsContainingPoints(a,b,c,d,e); }; + auto getCellsContainingPointsFunc=[self](const double *a, int b,double c, MCAuto& d, MCAuto& e) { self->getCellsContainingPoints(a,b,c,d,e); }; return Mesh_getCellsContainingPointsLike(p,eps,self,getCellsContainingPointsFunc); } PyObject *getCellsContainingPointsLinearPartOnlyOnNonDynType(PyObject *p, double eps) const { - auto getCellsContainingPointsFunc=[self](const double *a, int b,double c, MCAuto& d, MCAuto& e) { self->getCellsContainingPointsLinearPartOnlyOnNonDynType(a,b,c,d,e); }; + auto getCellsContainingPointsFunc=[self](const double *a, int b,double c, MCAuto& d, MCAuto& e) { self->getCellsContainingPointsLinearPartOnlyOnNonDynType(a,b,c,d,e); }; return Mesh_getCellsContainingPointsLike(p,eps,self,getCellsContainingPointsFunc); } @@ -754,91 +838,91 @@ namespace MEDCoupling DataArrayDouble *a; DataArrayDoubleTuple *aa; std::vector bb; - int sw; + mcIdType sw; int spaceDim=self->getSpaceDimension(); const char msg[]="Python wrap of MEDCouplingUMesh::getCellsContainingPoint : "; const double *pos=convertObjToPossibleCpp5_Safe(p,sw,val,a,aa,bb,msg,1,spaceDim,true); - std::vector elts; + std::vector elts; self->getCellsContainingPoint(pos,eps,elts); - DataArrayInt *ret=DataArrayInt::New(); + DataArrayIdType *ret=DataArrayIdType::New(); ret->alloc((int)elts.size(),1); std::copy(elts.begin(),elts.end(),ret->getPointer()); - return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 ); + return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 ); } virtual PyObject *getReverseNodalConnectivity() const { - MCAuto d0=DataArrayInt::New(); - MCAuto d1=DataArrayInt::New(); + MCAuto d0=DataArrayIdType::New(); + MCAuto d1=DataArrayIdType::New(); self->getReverseNodalConnectivity(d0,d1); PyObject *ret=PyTuple_New(2); - PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(d0.retn()),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(d1.retn()),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(d0.retn()),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(d1.retn()),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); return ret; } void renumberCells(PyObject *li, bool check=true) { - int sw,sz(-1); - int v0; std::vector v1; - const int *ids(convertIntStarLikePyObjToCppIntStar(li,sw,sz,v0,v1)); + mcIdType sw,sz(-1); + mcIdType v0; std::vector v1; + const mcIdType *ids(convertIntStarLikePyObjToCppIntStar(li,sw,sz,v0,v1)); self->renumberCells(ids,check); } PyObject *checkGeoEquivalWith(const MEDCouplingMesh *other, int levOfCheck, double prec) const { - DataArrayInt *cellCor, *nodeCor; + DataArrayIdType *cellCor, *nodeCor; self->checkGeoEquivalWith(other,levOfCheck,prec,cellCor,nodeCor); PyObject *res = PyList_New(2); - PyList_SetItem(res,0,SWIG_NewPointerObj(SWIG_as_voidptr(cellCor),SWIGTYPE_p_MEDCoupling__DataArrayInt, cellCor?SWIG_POINTER_OWN | 0:0 )); - PyList_SetItem(res,1,SWIG_NewPointerObj(SWIG_as_voidptr(nodeCor),SWIGTYPE_p_MEDCoupling__DataArrayInt, nodeCor?SWIG_POINTER_OWN | 0:0 )); + PyList_SetItem(res,0,SWIG_NewPointerObj(SWIG_as_voidptr(cellCor),SWIGTITraits::TI, cellCor?SWIG_POINTER_OWN | 0:0 )); + PyList_SetItem(res,1,SWIG_NewPointerObj(SWIG_as_voidptr(nodeCor),SWIGTITraits::TI, nodeCor?SWIG_POINTER_OWN | 0:0 )); return res; } PyObject *checkDeepEquivalWith(const MEDCouplingMesh *other, int cellCompPol, double prec) const { - DataArrayInt *cellCor=0,*nodeCor=0; + DataArrayIdType *cellCor=0,*nodeCor=0; self->checkDeepEquivalWith(other,cellCompPol,prec,cellCor,nodeCor); PyObject *res = PyList_New(2); - PyList_SetItem(res,0,SWIG_NewPointerObj(SWIG_as_voidptr(cellCor),SWIGTYPE_p_MEDCoupling__DataArrayInt, cellCor?SWIG_POINTER_OWN | 0:0 )); - PyList_SetItem(res,1,SWIG_NewPointerObj(SWIG_as_voidptr(nodeCor),SWIGTYPE_p_MEDCoupling__DataArrayInt, nodeCor?SWIG_POINTER_OWN | 0:0 )); + PyList_SetItem(res,0,SWIG_NewPointerObj(SWIG_as_voidptr(cellCor),SWIGTITraits::TI, cellCor?SWIG_POINTER_OWN | 0:0 )); + PyList_SetItem(res,1,SWIG_NewPointerObj(SWIG_as_voidptr(nodeCor),SWIGTITraits::TI, nodeCor?SWIG_POINTER_OWN | 0:0 )); return res; } - DataArrayInt *checkDeepEquivalOnSameNodesWith(const MEDCouplingMesh *other, int cellCompPol, double prec) const + DataArrayIdType *checkDeepEquivalOnSameNodesWith(const MEDCouplingMesh *other, int cellCompPol, double prec) const { - DataArrayInt *cellCor=0; + DataArrayIdType *cellCor=0; self->checkDeepEquivalOnSameNodesWith(other,cellCompPol,prec,cellCor); return cellCor; } - DataArrayInt *getCellIdsFullyIncludedInNodeIds(PyObject *li) const + DataArrayIdType *getCellIdsFullyIncludedInNodeIds(PyObject *li) const { void *da=0; - int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_MEDCoupling__DataArrayInt, 0 | 0 ); + int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits::TI, 0 | 0 ); if (!SWIG_IsOK(res1)) { - int size; - INTERP_KERNEL::AutoPtr tmp=convertPyToNewIntArr2(li,&size); - return self->getCellIdsFullyIncludedInNodeIds(tmp,((const int *)tmp)+size); + mcIdType size; + INTERP_KERNEL::AutoPtr tmp=convertPyToNewIntArr2(li,&size); + return self->getCellIdsFullyIncludedInNodeIds(tmp,((const mcIdType *)tmp)+size); } else { - DataArrayInt *da2=reinterpret_cast< DataArrayInt * >(da); + DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da); if(!da2) - throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !"); + throw INTERP_KERNEL::Exception("Not null DataArrayIdType instance expected !"); da2->checkAllocated(); return self->getCellIdsFullyIncludedInNodeIds(da2->getConstPointer(),da2->getConstPointer()+da2->getNbOfElems()); } } PyObject *getNodeIdsOfCell(int cellId) const { - std::vector conn; + std::vector conn; self->getNodeIdsOfCell(cellId,conn); return convertIntArrToPyList2(conn); } - PyObject *getCoordinatesOfNode(int nodeId) const + PyObject *getCoordinatesOfNode(mcIdType nodeId) const { std::vector coo; self->getCoordinatesOfNode(nodeId,coo); @@ -851,7 +935,7 @@ namespace MEDCoupling DataArrayDouble *a; DataArrayDoubleTuple *aa; std::vector bb; - int sw; + mcIdType sw; int spaceDim=self->getSpaceDimension(); const char msg[]="Python wrap of MEDCouplingPointSet::scale : "; const double *pointPtr=convertObjToPossibleCpp5_Safe(point,sw,val,a,aa,bb,msg,1,spaceDim,true); @@ -881,14 +965,14 @@ namespace MEDCoupling PyObject *buildPart(PyObject *li) const { - int szArr,sw,iTypppArr; - std::vector stdvecTyyppArr; - const int *tmp=convertIntStarLikePyObjToCppIntStar(li,sw,szArr,iTypppArr,stdvecTyyppArr); + mcIdType szArr,sw,iTypppArr; + std::vector stdvecTyyppArr; + const mcIdType *tmp=convertIntStarLikePyObjToCppIntStar(li,sw,szArr,iTypppArr,stdvecTyyppArr); MEDCouplingMesh *ret=self->buildPart(tmp,tmp+szArr); - if(sw==3)//DataArrayInt + if(sw==3)//DataArrayIdType { - void *argp; SWIG_ConvertPtr(li,&argp,SWIGTYPE_p_MEDCoupling__DataArrayInt,0|0); - DataArrayInt *argpt=reinterpret_cast< MEDCoupling::DataArrayInt * >(argp); + void *argp; SWIG_ConvertPtr(li,&argp,SWIGTITraits::TI,0|0); + DataArrayIdType *argpt=reinterpret_cast< MEDCoupling::DataArrayIdType * >(argp); std::string name=argpt->getName(); if(!name.empty()) ret->setName(name.c_str()); @@ -898,15 +982,15 @@ namespace MEDCoupling PyObject *buildPartAndReduceNodes(PyObject *li) const { - int szArr,sw,iTypppArr; - std::vector stdvecTyyppArr; - DataArrayInt *arr=0; - const int *tmp=convertIntStarLikePyObjToCppIntStar(li,sw,szArr,iTypppArr,stdvecTyyppArr); + mcIdType szArr,sw,iTypppArr; + std::vector stdvecTyyppArr; + DataArrayIdType *arr=0; + const mcIdType *tmp=convertIntStarLikePyObjToCppIntStar(li,sw,szArr,iTypppArr,stdvecTyyppArr); MEDCouplingMesh *ret=self->buildPartAndReduceNodes(tmp,tmp+szArr,arr); - if(sw==3)//DataArrayInt + if(sw==3)//DataArrayIdType { - void *argp; SWIG_ConvertPtr(li,&argp,SWIGTYPE_p_MEDCoupling__DataArrayInt,0|0); - DataArrayInt *argpt=reinterpret_cast< MEDCoupling::DataArrayInt * >(argp); + void *argp; SWIG_ConvertPtr(li,&argp,SWIGTITraits::TI,0|0); + DataArrayIdType *argpt=reinterpret_cast< MEDCoupling::DataArrayIdType * >(argp); std::string name=argpt->getName(); if(!name.empty()) ret->setName(name.c_str()); @@ -914,22 +998,22 @@ namespace MEDCoupling // PyObject *res = PyList_New(2); PyObject *obj0=convertMesh(ret, SWIG_POINTER_OWN | 0 ); - PyObject *obj1=SWIG_NewPointerObj(SWIG_as_voidptr(arr),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 ); + PyObject *obj1=SWIG_NewPointerObj(SWIG_as_voidptr(arr),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 ); PyList_SetItem(res,0,obj0); PyList_SetItem(res,1,obj1); return res; } - PyObject *buildPartRangeAndReduceNodes(int beginCellIds, int endCellIds, int stepCellIds) const + PyObject *buildPartRangeAndReduceNodes(mcIdType beginCellIds, mcIdType endCellIds, mcIdType stepCellIds) const { - int a,b,c; - DataArrayInt *arr=0; + mcIdType a,b,c; + DataArrayIdType *arr=0; MEDCouplingMesh *ret=self->buildPartRangeAndReduceNodes(beginCellIds,endCellIds,stepCellIds,a,b,c,arr); PyObject *res = PyTuple_New(2); PyObject *obj0=convertMesh(ret, SWIG_POINTER_OWN | 0 ); PyObject *obj1=0; if(arr) - obj1=SWIG_NewPointerObj(SWIG_as_voidptr(arr),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 ); + obj1=SWIG_NewPointerObj(SWIG_as_voidptr(arr),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 ); else obj1=PySlice_New(PyInt_FromLong(a),PyInt_FromLong(b),PyInt_FromLong(b)); PyTuple_SetItem(res,0,obj0); @@ -939,59 +1023,59 @@ namespace MEDCoupling PyObject *getDistributionOfTypes() const { - std::vector vals=self->getDistributionOfTypes(); + std::vector vals=self->getDistributionOfTypes(); if(vals.size()%3!=0) throw INTERP_KERNEL::Exception("Internal Error detected in wrap python ! code returned by MEDCouplingMesh::getDistributionOfTypes is not so that %3==0 !"); - PyObject *ret=PyList_New((int)vals.size()/3); - for(int j=0;j<(int)vals.size()/3;j++) + PyObject *ret=PyList_New((mcIdType)vals.size()/3); + for(std::size_t j=0;j code; - std::vector idsPerType; - convertFromPyObjVectorOfObj(li2,SWIGTYPE_p_MEDCoupling__DataArrayInt,"DataArrayInt",idsPerType); + std::vector code; + std::vector idsPerType; + convertFromPyObjVectorOfObj(li2,SWIGTITraits::TI,"DataArrayIdType",idsPerType); convertPyToNewIntArr4(li,1,3,code); return self->checkTypeConsistencyAndContig(code,idsPerType); } - PyObject *splitProfilePerType(const DataArrayInt *profile, bool smartPflKiller=true) const + PyObject *splitProfilePerType(const DataArrayIdType *profile, bool smartPflKiller=true) const { - std::vector code; - std::vector idsInPflPerType; - std::vector idsPerType; + std::vector code; + std::vector idsInPflPerType; + std::vector idsPerType; self->splitProfilePerType(profile,code,idsInPflPerType,idsPerType,smartPflKiller); PyObject *ret=PyTuple_New(3); // if(code.size()%3!=0) throw INTERP_KERNEL::Exception("Internal Error detected in wrap python ! code returned by MEDCouplingMesh::splitProfilePerType is not so that %3==0 !"); - PyObject *ret0=PyList_New((int)code.size()/3); - for(int j=0;j<(int)code.size()/3;j++) + PyObject *ret0=PyList_New((mcIdType)code.size()/3); + for(std::size_t j=0;j::TI, SWIG_POINTER_OWN | 0 )); PyTuple_SetItem(ret,1,ret1); - int n=idsPerType.size(); + std::size_t n=idsPerType.size(); PyObject *ret2=PyList_New(n); - for(int i=0;i::TI, SWIG_POINTER_OWN | 0 )); PyTuple_SetItem(ret,2,ret2); return ret; } @@ -1002,7 +1086,7 @@ namespace MEDCoupling DataArrayDouble *a; DataArrayDoubleTuple *aa; std::vector bb; - int sw; + mcIdType sw; int spaceDim=self->getSpaceDimension(); const char msg[]="Python wrap of MEDCouplingPointSet::translate : "; const double *vectorPtr=convertObjToPossibleCpp5_Safe(vector,sw,val,a,aa,bb,msg,1,spaceDim,true); @@ -1016,7 +1100,7 @@ namespace MEDCoupling DataArrayDouble *a; DataArrayDoubleTuple *aa; std::vector bb; - int sw; + mcIdType sw; int spaceDim=self->getSpaceDimension(); const double *centerPtr=convertObjToPossibleCpp5_Safe(center,sw,val,a,aa,bb,msg,1,spaceDim,true); self->rotate(centerPtr,0,alpha); @@ -1029,7 +1113,7 @@ namespace MEDCoupling DataArrayDouble *a,*a2; DataArrayDoubleTuple *aa,*aa2; std::vector bb,bb2; - int sw; + mcIdType sw; int spaceDim=self->getSpaceDimension(); const double *centerPtr=convertObjToPossibleCpp5_Safe(center,sw,val,a,aa,bb,msg,1,spaceDim,true); const double *vectorPtr=convertObjToPossibleCpp5_Safe(vector,sw,val2,a2,aa2,bb2,msg,1,spaceDim,false);//vectorPtr can be null in case of space dim 2 @@ -1049,16 +1133,16 @@ namespace MEDCoupling virtual PyObject *getTinySerializationInformation() const { std::vector a0; - std::vector a1; + std::vector a1; std::vector a2; self->getTinySerializationInformation(a0,a1,a2); PyObject *ret(PyTuple_New(3)); PyTuple_SetItem(ret,0,convertDblArrToPyList2(a0)); PyTuple_SetItem(ret,1,convertIntArrToPyList2(a1)); - int sz(a2.size()); + std::size_t sz(a2.size()); PyObject *ret2(PyList_New(sz)); { - for(int i=0;iserialize(a0Tmp,a1Tmp); PyObject *ret(PyTuple_New(2)); - PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(a0Tmp),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(a0Tmp),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(a1Tmp),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 )); return ret; } - void resizeForUnserialization(const std::vector& tinyInfo, DataArrayInt *a1, DataArrayDouble *a2) const + void resizeForUnserialization(const std::vector& tinyInfo, DataArrayIdType *a1, DataArrayDouble *a2) const { std::vector littleStrings; self->resizeForUnserialization(tinyInfo,a1,a2,littleStrings); @@ -1097,21 +1181,21 @@ namespace MEDCoupling static const char MSG[]="MEDCouplingMesh.__setstate__ : expected input is a tuple of size 2 !"; if(!PyTuple_Check(inp)) throw INTERP_KERNEL::Exception(MSG); - int sz(PyTuple_Size(inp)); + std::size_t sz(PyTuple_Size(inp)); if(sz!=2) throw INTERP_KERNEL::Exception(MSG); PyObject *elt0(PyTuple_GetItem(inp,0)); PyObject *elt1(PyTuple_GetItem(inp,1)); std::vector a0; - std::vector a1; + std::vector a1; std::vector a2; - DataArrayInt *b0(0); + DataArrayIdType *b0(0); DataArrayDouble *b1(0); { if(!PyTuple_Check(elt0) && PyTuple_Size(elt0)!=3) throw INTERP_KERNEL::Exception(MSG); PyObject *a0py(PyTuple_GetItem(elt0,0)),*a1py(PyTuple_GetItem(elt0,1)),*a2py(PyTuple_GetItem(elt0,2)); - int tmp(-1); + mcIdType tmp(-1); fillArrayWithPyListDbl3(a0py,tmp,a0); convertPyToNewIntArr3(a1py,a1); fillStringVector(a2py,a2); @@ -1121,10 +1205,10 @@ namespace MEDCoupling throw INTERP_KERNEL::Exception(MSG); PyObject *b0py(PyTuple_GetItem(elt1,0)),*b1py(PyTuple_GetItem(elt1,1)); void *argp(0); - int status(SWIG_ConvertPtr(b0py,&argp,SWIGTYPE_p_MEDCoupling__DataArrayInt,0|0)); + int status(SWIG_ConvertPtr(b0py,&argp,SWIGTITraits::TI,0|0)); if(!SWIG_IsOK(status)) throw INTERP_KERNEL::Exception(MSG); - b0=reinterpret_cast(argp); + b0=reinterpret_cast(argp); status=SWIG_ConvertPtr(b1py,&argp,SWIGTYPE_p_MEDCoupling__DataArrayDouble,0|0); if(!SWIG_IsOK(status)) throw INTERP_KERNEL::Exception(MSG); @@ -1214,10 +1298,10 @@ namespace MEDCoupling class MEDCouplingSkyLineArray { public: - static MEDCouplingSkyLineArray *BuildFromPolyhedronConn( const DataArrayInt* c, const DataArrayInt* cI ); + static MEDCouplingSkyLineArray *BuildFromPolyhedronConn( const DataArrayIdType* c, const DataArrayIdType* cI ); - void set( DataArrayInt* index, DataArrayInt* value ); - void set3( DataArrayInt* superIndex, DataArrayInt* index, DataArrayInt* value ); + void set( DataArrayIdType* index, DataArrayIdType* value ); + void set3( DataArrayIdType* superIndex, DataArrayIdType* index, DataArrayIdType* value ); int getSuperNumberOf() const; int getNumberOf() const; @@ -1226,7 +1310,12 @@ namespace MEDCoupling void deletePack(const int i, const int j); void deleteSimplePack(const int i); - void deleteSimplePacks(const DataArrayInt* idx); + void deleteSimplePacks(const DataArrayIdType* idx); + + MEDCouplingSkyLineArray *groupPacks(const DataArrayIdType *indexedPacks) const; + MEDCouplingSkyLineArray *uniqueNotSortedByPack() const; + + MEDCouplingSkyLineArray *deepCopy() const; %extend { @@ -1235,12 +1324,12 @@ namespace MEDCoupling return MEDCouplingSkyLineArray::New(); } - MEDCouplingSkyLineArray( const std::vector& index, const std::vector& value) + MEDCouplingSkyLineArray( const std::vector& index, const std::vector& value) { return MEDCouplingSkyLineArray::New(index, value); } - MEDCouplingSkyLineArray( DataArrayInt* index, DataArrayInt* value ) + MEDCouplingSkyLineArray( DataArrayIdType* index, DataArrayIdType* value ) { return MEDCouplingSkyLineArray::New(index, value); } @@ -1255,40 +1344,40 @@ namespace MEDCoupling return self->simpleRepr(); } - DataArrayInt *getSuperIndexArray() const + DataArrayIdType *getSuperIndexArray() const { - DataArrayInt *ret(self->getSuperIndexArray()); + DataArrayIdType *ret(self->getSuperIndexArray()); if(ret) ret->incrRef(); return ret; } - DataArrayInt *getIndexArray() const + DataArrayIdType *getIndexArray() const { - DataArrayInt *ret(self->getIndexArray()); + DataArrayIdType *ret(self->getIndexArray()); if(ret) ret->incrRef(); return ret; } - DataArrayInt *getValuesArray() const + DataArrayIdType *getValuesArray() const { - DataArrayInt *ret(self->getValuesArray()); + DataArrayIdType *ret(self->getValuesArray()); if(ret) ret->incrRef(); return ret; } - PyObject *getSimplePackSafe(int absolutePackId) const + PyObject *getSimplePackSafe(mcIdType absolutePackId) const { - std::vector ret; + std::vector ret; self->getSimplePackSafe(absolutePackId,ret); return convertIntArrToPyList2(ret); } PyObject *findPackIds(PyObject *superPackIndices, PyObject *pack) const { - std::vector vpack, vspIdx, out; + std::vector vpack, vspIdx, out; convertPyToNewIntArr3(superPackIndices,vspIdx); convertPyToNewIntArr3(pack,vpack); @@ -1297,44 +1386,61 @@ namespace MEDCoupling return convertIntArrToPyList2(out); } - void pushBackPack(const int i, PyObject *pack) + void pushBackPack(const mcIdType i, PyObject *pack) { - std::vector vpack; + std::vector vpack; convertPyToNewIntArr3(pack,vpack); self->pushBackPack(i,vpack.data(), vpack.data()+vpack.size()); } - void replaceSimplePack(const int idx, PyObject *pack) + void replaceSimplePack(const mcIdType idx, PyObject *pack) { - std::vector vpack; + std::vector vpack; convertPyToNewIntArr3(pack,vpack); self->replaceSimplePack(idx, vpack.data(), vpack.data()+vpack.size()); } - void replaceSimplePacks(const DataArrayInt* idx, PyObject *listePacks) + void replaceSimplePacks(const DataArrayIdType* idx, PyObject *listePacks) { - std::vector packs; - convertFromPyObjVectorOfObj(listePacks,SWIGTYPE_p_MEDCoupling__DataArrayInt,"DataArrayInt",packs); + std::vector packs; + convertFromPyObjVectorOfObj(listePacks,SWIGTITraits::TI,"DataArrayIdType",packs); self->replaceSimplePacks(idx, packs); } + + static MEDCouplingSkyLineArray *AggregatePacks(PyObject *sks) + { + std::vector sksCpp; + convertFromPyObjVectorOfObj(sks,SWIGTYPE_p_MEDCoupling__MEDCouplingSkyLineArray,"MEDCouplingSkyLineArray",sksCpp); + return MEDCoupling::MEDCouplingSkyLineArray::AggregatePacks(sksCpp); + } - void replacePack(const int superIdx, const int idx, PyObject *pack) + void replacePack(const mcIdType superIdx, const mcIdType idx, PyObject *pack) { - std::vector vpack; + std::vector vpack; convertPyToNewIntArr3(pack,vpack); self->replacePack(superIdx, idx, vpack.data(), vpack.data()+vpack.size()); } PyObject *convertToPolyhedronConn() const { - MCAuto d0=DataArrayInt::New(); - MCAuto d1=DataArrayInt::New(); + MCAuto d0=DataArrayIdType::New(); + MCAuto d1=DataArrayIdType::New(); self->convertToPolyhedronConn(d0,d1); PyObject *ret=PyTuple_New(2); - PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(d0.retn()),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(d1.retn()),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(d0.retn()),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(d1.retn()),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); return ret; } + + PyObject *thresholdPerPack(mcIdType threshold) const + { + MCAuto left, right; + self->thresholdPerPack(threshold,left,right); + PyObject *ret=PyTuple_New(2); + PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(left.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingSkyLineArray, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(right.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingSkyLineArray, SWIG_POINTER_OWN | 0 )); + return ret; + } } }; } @@ -1361,17 +1467,17 @@ namespace MEDCoupling virtual void tryToShareSameCoordsPermute(const MEDCouplingPointSet& other, double epsilon); static DataArrayDouble *MergeNodesArray(const MEDCouplingPointSet *m1, const MEDCouplingPointSet *m2); static MEDCouplingPointSet *BuildInstanceFromMeshType(MEDCouplingMeshType type); - static DataArrayInt *ComputeNbOfInteractionsWithSrcCells(const MEDCouplingPointSet *srcMesh, const MEDCouplingPointSet *trgMesh, double eps); - virtual DataArrayInt *computeFetchedNodeIds() const; + static DataArrayIdType *ComputeNbOfInteractionsWithSrcCells(const MEDCouplingPointSet *srcMesh, const MEDCouplingPointSet *trgMesh, double eps); + virtual DataArrayIdType *computeFetchedNodeIds() const; virtual int getNumberOfNodesInCell(int cellId) const; virtual MEDCouplingPointSet *buildBoundaryMesh(bool keepCoords) const; - virtual DataArrayInt *getCellsInBoundingBox(const INTERP_KERNEL::DirectedBoundingBox& bbox, double eps); - virtual DataArrayInt *zipCoordsTraducer(); - virtual DataArrayInt *findBoundaryNodes() const; - virtual DataArrayInt *zipConnectivityTraducer(int compType, int startCellId=0); + virtual DataArrayIdType *getCellsInBoundingBox(const INTERP_KERNEL::DirectedBoundingBox& bbox, double eps); + virtual DataArrayIdType *zipCoordsTraducer(); + virtual DataArrayIdType *findBoundaryNodes() const; + virtual DataArrayIdType *zipConnectivityTraducer(int compType, int startCellId=0); virtual MEDCouplingPointSet *mergeMyselfWithOnSameCoords(const MEDCouplingPointSet *other) const; virtual void checkFullyDefined() const; - virtual bool isEmptyMesh(const std::vector& tinyInfo) const; + virtual bool isEmptyMesh(const std::vector& tinyInfo) const; virtual MEDCouplingPointSet *deepCopyConnectivityOnly() const; virtual DataArrayDouble *getBoundingBoxForBBTree(double arcDetEps=1e-12) const; virtual void renumberNodesWithOffsetInConn(int offset); @@ -1385,23 +1491,23 @@ namespace MEDCoupling return self->simpleRepr(); } - PyObject *buildNewNumberingFromCommonNodesFormat(const DataArrayInt *comm, const DataArrayInt *commIndex) const + PyObject *buildNewNumberingFromCommonNodesFormat(const DataArrayIdType *comm, const DataArrayIdType *commIndex) const { - int newNbOfNodes; - DataArrayInt *ret0=self->buildNewNumberingFromCommonNodesFormat(comm,commIndex,newNbOfNodes); + mcIdType newNbOfNodes; + DataArrayIdType *ret0=self->buildNewNumberingFromCommonNodesFormat(comm,commIndex,newNbOfNodes); PyObject *res = PyList_New(2); - PyList_SetItem(res,0,SWIG_NewPointerObj(SWIG_as_voidptr(ret0),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyList_SetItem(res,1,SWIG_From_int(newNbOfNodes)); + PyList_SetItem(res,0,SWIG_NewPointerObj(SWIG_as_voidptr(ret0),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); + PyList_SetItem(res,1,PyInt_FromLong(newNbOfNodes)); return res; } - PyObject *findCommonNodes(double prec, int limitTupleId=-1) const + PyObject *findCommonNodes(double prec, mcIdType limitTupleId=-1) const { - DataArrayInt *comm, *commIndex; + DataArrayIdType *comm, *commIndex; self->findCommonNodes(prec,limitTupleId,comm,commIndex); PyObject *res = PyList_New(2); - PyList_SetItem(res,0,SWIG_NewPointerObj(SWIG_as_voidptr(comm),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyList_SetItem(res,1,SWIG_NewPointerObj(SWIG_as_voidptr(commIndex),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyList_SetItem(res,0,SWIG_NewPointerObj(SWIG_as_voidptr(comm),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); + PyList_SetItem(res,1,SWIG_NewPointerObj(SWIG_as_voidptr(commIndex),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); return res; } @@ -1415,14 +1521,14 @@ namespace MEDCoupling PyObject *buildPartOfMySelf(PyObject *li, bool keepCoords=true) const { - int szArr,sw,iTypppArr; - std::vector stdvecTyyppArr; - const int *tmp=convertIntStarLikePyObjToCppIntStar(li,sw,szArr,iTypppArr,stdvecTyyppArr); + mcIdType szArr,sw,iTypppArr; + std::vector stdvecTyyppArr; + const mcIdType *tmp=convertIntStarLikePyObjToCppIntStar(li,sw,szArr,iTypppArr,stdvecTyyppArr); MEDCouplingPointSet *ret=self->buildPartOfMySelf(tmp,tmp+szArr,keepCoords); - if(sw==3)//DataArrayInt + if(sw==3)//DataArrayIdType { - void *argp; SWIG_ConvertPtr(li,&argp,SWIGTYPE_p_MEDCoupling__DataArrayInt,0|0); - DataArrayInt *argpt=reinterpret_cast< MEDCoupling::DataArrayInt * >(argp); + void *argp; SWIG_ConvertPtr(li,&argp,SWIGTITraits::TI,0|0); + DataArrayIdType *argpt=reinterpret_cast< MEDCoupling::DataArrayIdType * >(argp); std::string name=argpt->getName(); if(!name.empty()) ret->setName(name.c_str()); @@ -1432,14 +1538,14 @@ namespace MEDCoupling PyObject *buildPartOfMySelfNode(PyObject *li, bool fullyIn) const { - int szArr,sw,iTypppArr; - std::vector stdvecTyyppArr; - const int *tmp=convertIntStarLikePyObjToCppIntStar(li,sw,szArr,iTypppArr,stdvecTyyppArr); + mcIdType szArr,sw,iTypppArr; + std::vector stdvecTyyppArr; + const mcIdType *tmp=convertIntStarLikePyObjToCppIntStar(li,sw,szArr,iTypppArr,stdvecTyyppArr); MEDCouplingPointSet *ret=self->buildPartOfMySelfNode(tmp,tmp+szArr,fullyIn); - if(sw==3)//DataArrayInt + if(sw==3)//DataArrayIdType { - void *argp; SWIG_ConvertPtr(li,&argp,SWIGTYPE_p_MEDCoupling__DataArrayInt,0|0); - DataArrayInt *argpt=reinterpret_cast< MEDCoupling::DataArrayInt * >(argp); + void *argp; SWIG_ConvertPtr(li,&argp,SWIGTITraits::TI,0|0); + DataArrayIdType *argpt=reinterpret_cast< MEDCoupling::DataArrayIdType * >(argp); std::string name=argpt->getName(); if(!name.empty()) ret->setName(name.c_str()); @@ -1449,14 +1555,14 @@ namespace MEDCoupling virtual PyObject *buildPartOfMySelfKeepCoords(PyObject *li) const { - int szArr,sw,iTypppArr; - std::vector stdvecTyyppArr; - const int *tmp=convertIntStarLikePyObjToCppIntStar(li,sw,szArr,iTypppArr,stdvecTyyppArr); + mcIdType szArr,sw,iTypppArr; + std::vector stdvecTyyppArr; + const mcIdType *tmp=convertIntStarLikePyObjToCppIntStar(li,sw,szArr,iTypppArr,stdvecTyyppArr); MEDCouplingPointSet *ret=self->buildPartOfMySelfKeepCoords(tmp,tmp+szArr); - if(sw==3)//DataArrayInt + if(sw==3)//DataArrayIdType { - void *argp; SWIG_ConvertPtr(li,&argp,SWIGTYPE_p_MEDCoupling__DataArrayInt,0|0); - DataArrayInt *argpt=reinterpret_cast< MEDCoupling::DataArrayInt * >(argp); + void *argp; SWIG_ConvertPtr(li,&argp,SWIGTITraits::TI,0|0); + DataArrayIdType *argpt=reinterpret_cast< MEDCoupling::DataArrayIdType * >(argp); std::string name=argpt->getName(); if(!name.empty()) ret->setName(name.c_str()); @@ -1464,7 +1570,7 @@ namespace MEDCoupling return convertMesh(ret, SWIG_POINTER_OWN | 0 ); } - virtual PyObject *buildPartOfMySelfKeepCoordsSlice(int start, int end, int step) const + virtual PyObject *buildPartOfMySelfKeepCoordsSlice(mcIdType start, mcIdType end, mcIdType step) const { MEDCouplingPointSet *ret=self->buildPartOfMySelfKeepCoordsSlice(start,end,step); return convertMesh(ret, SWIG_POINTER_OWN | 0 ); @@ -1472,14 +1578,14 @@ namespace MEDCoupling PyObject *buildFacePartOfMySelfNode(PyObject *li, bool fullyIn) const { - int szArr,sw,iTypppArr; - std::vector stdvecTyyppArr; - const int *tmp=convertIntStarLikePyObjToCppIntStar(li,sw,szArr,iTypppArr,stdvecTyyppArr); + mcIdType szArr,sw,iTypppArr; + std::vector stdvecTyyppArr; + const mcIdType *tmp=convertIntStarLikePyObjToCppIntStar(li,sw,szArr,iTypppArr,stdvecTyyppArr); MEDCouplingPointSet *ret=self->buildFacePartOfMySelfNode(tmp,tmp+szArr,fullyIn); - if(sw==3)//DataArrayInt + if(sw==3)//DataArrayIdType { - void *argp; SWIG_ConvertPtr(li,&argp,SWIGTYPE_p_MEDCoupling__DataArrayInt,0|0); - DataArrayInt *argpt=reinterpret_cast< MEDCoupling::DataArrayInt * >(argp); + void *argp; SWIG_ConvertPtr(li,&argp,SWIGTITraits::TI,0|0); + DataArrayIdType *argpt=reinterpret_cast< MEDCoupling::DataArrayIdType * >(argp); std::string name=argpt->getName(); if(!name.empty()) ret->setName(name.c_str()); @@ -1487,19 +1593,19 @@ namespace MEDCoupling return convertMesh(ret, SWIG_POINTER_OWN | 0 ); } - void renumberNodes(PyObject *li, int newNbOfNodes) + void renumberNodes(PyObject *li, mcIdType newNbOfNodes) { - int szArr,sw,iTypppArr; - std::vector stdvecTyyppArr; - const int *tmp=convertIntStarLikePyObjToCppIntStar(li,sw,szArr,iTypppArr,stdvecTyyppArr); + mcIdType szArr,sw,iTypppArr; + std::vector stdvecTyyppArr; + const mcIdType *tmp=convertIntStarLikePyObjToCppIntStar(li,sw,szArr,iTypppArr,stdvecTyyppArr); self->renumberNodes(tmp,newNbOfNodes); } - void renumberNodesCenter(PyObject *li, int newNbOfNodes) + void renumberNodesCenter(PyObject *li, mcIdType newNbOfNodes) { - int szArr,sw,iTypppArr; - std::vector stdvecTyyppArr; - const int *tmp=convertIntStarLikePyObjToCppIntStar(li,sw,szArr,iTypppArr,stdvecTyyppArr); + mcIdType szArr,sw,iTypppArr; + std::vector stdvecTyyppArr; + const mcIdType *tmp=convertIntStarLikePyObjToCppIntStar(li,sw,szArr,iTypppArr,stdvecTyyppArr); self->renumberNodesCenter(tmp,newNbOfNodes); } @@ -1510,17 +1616,17 @@ namespace MEDCoupling DataArrayDouble *a,*a2; DataArrayDoubleTuple *aa,*aa2; std::vector bb,bb2; - int sw; + mcIdType sw; const char msg[]="Python wrap of MEDCouplingPointSet::findNodesOnLine : 1st parameter for point."; const char msg2[]="Python wrap of MEDCouplingPointSet::findNodesOnLine : 2nd parameter for vector."; const double *p=convertObjToPossibleCpp5_Safe(pt,sw,val,a,aa,bb,msg,1,spaceDim,true); const double *v=convertObjToPossibleCpp5_Safe(vec,sw,val2,a2,aa2,bb2,msg2,1,spaceDim,true); - std::vector nodes; + std::vector nodes; self->findNodesOnLine(p,v,eps,nodes); - DataArrayInt *ret=DataArrayInt::New(); - ret->alloc((int)nodes.size(),1); + DataArrayIdType *ret=DataArrayIdType::New(); + ret->alloc(nodes.size(),1); std::copy(nodes.begin(),nodes.end(),ret->getPointer()); - return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 ); + return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 ); } PyObject *findNodesOnPlane(PyObject *pt, PyObject *vec, double eps) const { @@ -1529,17 +1635,17 @@ namespace MEDCoupling DataArrayDouble *a,*a2; DataArrayDoubleTuple *aa,*aa2; std::vector bb,bb2; - int sw; + mcIdType sw; const char msg[]="Python wrap of MEDCouplingPointSet::findNodesOnPlane : 1st parameter for point."; const char msg2[]="Python wrap of MEDCouplingPointSet::findNodesOnPlane : 2nd parameter for vector."; const double *p=convertObjToPossibleCpp5_Safe(pt,sw,val,a,aa,bb,msg,1,spaceDim,true); const double *v=convertObjToPossibleCpp5_Safe(vec,sw,val2,a2,aa2,bb2,msg2,1,spaceDim,true); - std::vector nodes; + std::vector nodes; self->findNodesOnPlane(p,v,eps,nodes); - DataArrayInt *ret=DataArrayInt::New(); - ret->alloc((int)nodes.size(),1); + DataArrayIdType *ret=DataArrayIdType::New(); + ret->alloc(nodes.size(),1); std::copy(nodes.begin(),nodes.end(),ret->getPointer()); - return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 ); + return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 ); } PyObject *getNodeIdsNearPoint(PyObject *pt, double eps) const @@ -1548,49 +1654,49 @@ namespace MEDCoupling DataArrayDouble *a; DataArrayDoubleTuple *aa; std::vector bb; - int sw; + mcIdType sw; int spaceDim=self->getSpaceDimension(); const char msg[]="Python wrap of MEDCouplingPointSet::getNodeIdsNearPoint : "; const double *pos=convertObjToPossibleCpp5_Safe(pt,sw,val,a,aa,bb,msg,1,spaceDim,true); - DataArrayInt *ret=self->getNodeIdsNearPoint(pos,eps); - return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 ); + DataArrayIdType *ret=self->getNodeIdsNearPoint(pos,eps); + return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 ); } - PyObject *getNodeIdsNearPoints(PyObject *pt, int nbOfPoints, double eps) const + PyObject *getNodeIdsNearPoints(PyObject *pt, mcIdType nbOfPoints, double eps) const { - DataArrayInt *c=0,*cI=0; + DataArrayIdType *c=0,*cI=0; // double val; DataArrayDouble *a; DataArrayDoubleTuple *aa; std::vector bb; - int sw; + mcIdType sw; int spaceDim=self->getSpaceDimension(); const char msg[]="Python wrap of MEDCouplingPointSet::getNodeIdsNearPoints : "; const double *pos=convertObjToPossibleCpp5_Safe(pt,sw,val,a,aa,bb,msg,nbOfPoints,spaceDim,true); self->getNodeIdsNearPoints(pos,nbOfPoints,eps,c,cI); PyObject *ret=PyTuple_New(2); - PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(c),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(cI),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(c),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(cI),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); return ret; } PyObject *getNodeIdsNearPoints(PyObject *pt, double eps) const { - DataArrayInt *c=0,*cI=0; + DataArrayIdType *c=0,*cI=0; int spaceDim=self->getSpaceDimension(); double val; DataArrayDouble *a; DataArrayDoubleTuple *aa; std::vector bb; - int sw; - int nbOfTuples=-1; + mcIdType sw; + mcIdType nbOfTuples=-1; const double *ptPtr=convertObjToPossibleCpp5_Safe2(pt,sw,val,a,aa,bb,"Python wrap of MEDCouplingUMesh::getNodeIdsNearPoints",spaceDim,true,nbOfTuples); self->getNodeIdsNearPoints(ptPtr,nbOfTuples,eps,c,cI); // PyObject *ret=PyTuple_New(2); - PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(c),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(cI),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(c),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(cI),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); return ret; } @@ -1600,22 +1706,22 @@ namespace MEDCoupling DataArrayDouble *a; DataArrayDoubleTuple *aa; std::vector bb; - int sw; + mcIdType sw; int spaceDim=self->getSpaceDimension(); const char msg[]="Python wrap of MEDCouplingPointSet::getCellsInBoundingBox : "; const double *tmp=convertObjToPossibleCpp5_Safe(bbox,sw,val,a,aa,bb,msg,spaceDim,2,true); // - DataArrayInt *elems=self->getCellsInBoundingBox(tmp,eps); - return SWIG_NewPointerObj(SWIG_as_voidptr(elems),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 ); + DataArrayIdType *elems=self->getCellsInBoundingBox(tmp,eps); + return SWIG_NewPointerObj(SWIG_as_voidptr(elems),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 ); } void duplicateNodesInCoords(PyObject *li) { - int sw; - int singleVal; - std::vector multiVal; - std::pair > slic; - MEDCoupling::DataArrayInt *daIntTyypp=0; + mcIdType sw; + mcIdType singleVal; + std::vector multiVal; + std::pair > slic; + MEDCoupling::DataArrayIdType *daIntTyypp=0; convertIntStarOrSliceLikePyObjToCpp(li,self->getNumberOfNodes(),sw,singleVal,multiVal,slic,daIntTyypp); switch(sw) { @@ -1626,17 +1732,17 @@ namespace MEDCoupling case 4: return self->duplicateNodesInCoords(daIntTyypp->begin(),daIntTyypp->end()); default: - throw INTERP_KERNEL::Exception("MEDCouplingPointSet::duplicateNodesInCoords : unrecognized type entered, expected list of int, tuple of int or DataArrayInt !"); + throw INTERP_KERNEL::Exception("MEDCouplingPointSet::duplicateNodesInCoords : unrecognized type entered, expected list of int, tuple of int or DataArrayIdType !"); } } - virtual PyObject *findCommonCells(int compType, int startCellId=0) const + virtual PyObject *findCommonCells(int compType, mcIdType startCellId=0) const { - DataArrayInt *v0(nullptr),*v1(nullptr); + DataArrayIdType *v0(nullptr),*v1(nullptr); self->findCommonCells(compType,startCellId,v0,v1); PyObject *res = PyList_New(2); - PyList_SetItem(res,0,SWIG_NewPointerObj(SWIG_as_voidptr(v0),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyList_SetItem(res,1,SWIG_NewPointerObj(SWIG_as_voidptr(v1),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyList_SetItem(res,0,SWIG_NewPointerObj(SWIG_as_voidptr(v0),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); + PyList_SetItem(res,1,SWIG_NewPointerObj(SWIG_as_voidptr(v1),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); return res; } @@ -1653,18 +1759,18 @@ namespace MEDCoupling return ; } } - int res1(SWIG_ConvertPtr(li,&da,SWIGTYPE_p_MEDCoupling__DataArrayInt, 0 | 0 )); + int res1(SWIG_ConvertPtr(li,&da,SWIGTITraits::TI, 0 | 0 )); if (!SWIG_IsOK(res1)) { - int size; - INTERP_KERNEL::AutoPtr tmp=convertPyToNewIntArr2(li,&size); + mcIdType size; + INTERP_KERNEL::AutoPtr tmp=convertPyToNewIntArr2(li,&size); self->renumberNodesInConn(tmp); } else { - DataArrayInt *da2(reinterpret_cast< DataArrayInt * >(da)); + DataArrayIdType *da2(reinterpret_cast< DataArrayIdType * >(da)); if(!da2) - throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !"); + throw INTERP_KERNEL::Exception("Not null DataArrayIdType instance expected !"); da2->checkAllocated(); self->renumberNodesInConn(da2->getConstPointer()); } @@ -1672,21 +1778,21 @@ namespace MEDCoupling virtual PyObject *getNodeIdsInUse() const { - int ret1=-1; - DataArrayInt *ret0=self->getNodeIdsInUse(ret1); + mcIdType ret1=-1; + DataArrayIdType *ret0=self->getNodeIdsInUse(ret1); PyObject *ret=PyTuple_New(2); - PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(ret0),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(ret0),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); PyTuple_SetItem(ret,1,PyInt_FromLong(ret1)); return ret; } - virtual DataArrayInt *fillCellIdsToKeepFromNodeIds(PyObject *li, bool fullyIn) const + virtual DataArrayIdType *fillCellIdsToKeepFromNodeIds(PyObject *li, bool fullyIn) const { - DataArrayInt *ret(nullptr); + DataArrayIdType *ret(nullptr); // - int szArr,sw,iTypppArr; - std::vector stdvecTyyppArr; - const int *tmp=convertIntStarLikePyObjToCppIntStar(li,sw,szArr,iTypppArr,stdvecTyyppArr); + mcIdType szArr,sw,iTypppArr; + std::vector stdvecTyyppArr; + const mcIdType *tmp=convertIntStarLikePyObjToCppIntStar(li,sw,szArr,iTypppArr,stdvecTyyppArr); self->fillCellIdsToKeepFromNodeIds(tmp,tmp+szArr,fullyIn,ret); return ret; } @@ -1694,42 +1800,42 @@ namespace MEDCoupling virtual PyObject *mergeNodes(double precision) { bool ret1; - int ret2; - DataArrayInt *ret0=self->mergeNodes(precision,ret1,ret2); + mcIdType ret2; + DataArrayIdType *ret0=self->mergeNodes(precision,ret1,ret2); PyObject *res = PyList_New(3); - PyList_SetItem(res,0,SWIG_NewPointerObj(SWIG_as_voidptr(ret0),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyList_SetItem(res,0,SWIG_NewPointerObj(SWIG_as_voidptr(ret0),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); PyList_SetItem(res,1,SWIG_From_bool(ret1)); - PyList_SetItem(res,2,SWIG_From_int(ret2)); + PyList_SetItem(res,2,PyInt_FromLong(ret2)); return res; } virtual PyObject *mergeNodesCenter(double precision) { bool ret1; - int ret2; - DataArrayInt *ret0=self->mergeNodesCenter(precision,ret1,ret2); + mcIdType ret2; + DataArrayIdType *ret0=self->mergeNodesCenter(precision,ret1,ret2); PyObject *res = PyList_New(3); - PyList_SetItem(res,0,SWIG_NewPointerObj(SWIG_as_voidptr(ret0),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyList_SetItem(res,0,SWIG_NewPointerObj(SWIG_as_voidptr(ret0),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); PyList_SetItem(res,1,SWIG_From_bool(ret1)); - PyList_SetItem(res,2,SWIG_From_int(ret2)); + PyList_SetItem(res,2,PyInt_FromLong(ret2)); return res; } - DataArrayInt *getCellIdsLyingOnNodes(PyObject *li, bool fullyIn) const + DataArrayIdType *getCellIdsLyingOnNodes(PyObject *li, bool fullyIn) const { void *da=0; - int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_MEDCoupling__DataArrayInt, 0 | 0 ); + int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits::TI, 0 | 0 ); if (!SWIG_IsOK(res1)) { - int size; - INTERP_KERNEL::AutoPtr tmp=convertPyToNewIntArr2(li,&size); - return self->getCellIdsLyingOnNodes(tmp,((const int *)tmp)+size,fullyIn); + mcIdType size; + INTERP_KERNEL::AutoPtr tmp=convertPyToNewIntArr2(li,&size); + return self->getCellIdsLyingOnNodes(tmp,((const mcIdType *)tmp)+size,fullyIn); } else { - DataArrayInt *da2=reinterpret_cast< DataArrayInt * >(da); + DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da); if(!da2) - throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !"); + throw INTERP_KERNEL::Exception("Not null DataArrayIdType instance expected !"); da2->checkAllocated(); return self->getCellIdsLyingOnNodes(da2->getConstPointer(),da2->getConstPointer()+da2->getNbOfElems(),fullyIn); } @@ -1737,12 +1843,12 @@ namespace MEDCoupling MEDCouplingPointSet *__getitem__(PyObject *listOrDataArrI) { - int sw; - int singleVal; - std::vector multiVal; - std::pair > slic; - MEDCoupling::DataArrayInt *daIntTyypp=0; - int nbc=self->getNumberOfCells(); + mcIdType sw; + mcIdType singleVal; + std::vector multiVal; + std::pair > slic; + MEDCoupling::DataArrayIdType *daIntTyypp=0; + mcIdType nbc=self->getNumberOfCells(); convertIntStarOrSliceLikePyObjToCpp(listOrDataArrI,nbc,sw,singleVal,multiVal,slic,daIntTyypp); switch(sw) { @@ -1760,7 +1866,7 @@ namespace MEDCoupling { if(nbc+singleVal>0) { - int tmp=nbc+singleVal; + mcIdType tmp=nbc+singleVal; return self->buildPartOfMySelf(&tmp,&tmp+1,true); } else @@ -1787,25 +1893,25 @@ namespace MEDCoupling return self->buildPartOfMySelf(daIntTyypp->begin(),daIntTyypp->end(),true); } default: - throw INTERP_KERNEL::Exception("MEDCouplingUMesh::__getitem__ : unrecognized type in input ! Possibilities are : int, list or tuple of int DataArrayInt instance !"); + throw INTERP_KERNEL::Exception("MEDCouplingUMesh::__getitem__ : unrecognized type in input ! Possibilities are : int, list or tuple of int DataArrayIdType instance !"); } } - static void Rotate2DAlg(PyObject *center, double angle, int nbNodes, PyObject *coords) + static void Rotate2DAlg(PyObject *center, double angle, mcIdType nbNodes, PyObject *coords) { - int sz; + mcIdType sz; INTERP_KERNEL::AutoCPtr c=convertPyToNewDblArr2(center,&sz); INTERP_KERNEL::AutoCPtr coo=convertPyToNewDblArr2(coords,&sz); MEDCoupling::DataArrayDouble::Rotate2DAlg(c,angle,nbNodes,coo,coo); - for(int i=0;i c=convertPyToNewDblArr2(center,&sz); - int sw,nbNodes=0; + mcIdType sw,nbNodes=0; double val0; MEDCoupling::DataArrayDouble *val1=0; MEDCoupling::DataArrayDoubleTuple *val2=0; std::vector val3; const double *coo=convertObjToPossibleCpp5_Safe2(coords,sw,val0,val1,val2,val3, @@ -1815,22 +1921,22 @@ namespace MEDCoupling MEDCoupling::DataArrayDouble::Rotate2DAlg(c,angle,nbNodes,coo,const_cast(coo)); } - static void Rotate3DAlg(PyObject *center, PyObject *vect, double angle, int nbNodes, PyObject *coords) + static void Rotate3DAlg(PyObject *center, PyObject *vect, double angle, mcIdType nbNodes, PyObject *coords) { - int sz,sz2; + mcIdType sz,sz2; INTERP_KERNEL::AutoCPtr c=convertPyToNewDblArr2(center,&sz); INTERP_KERNEL::AutoCPtr coo=convertPyToNewDblArr2(coords,&sz); INTERP_KERNEL::AutoCPtr v=convertPyToNewDblArr2(vect,&sz2); MEDCoupling::DataArrayDouble::Rotate3DAlg(c,v,angle,nbNodes,coo,coo); - for(int i=0;i c=convertPyToNewDblArr2(center,&sz); - int sw,nbNodes=0; + mcIdType sw,nbNodes=0; double val0; MEDCoupling::DataArrayDouble *val1=0; MEDCoupling::DataArrayDoubleTuple *val2=0; std::vector val3; const double *coo=convertObjToPossibleCpp5_Safe2(coords,sw,val0,val1,val2,val3, @@ -1858,10 +1964,10 @@ namespace MEDCoupling PyObject *getAllConn() const { - int ret2; - const int *r=self->getAllConn(ret2); + mcIdType ret2; + const mcIdType *r=self->getAllConn(ret2); PyObject *ret=PyTuple_New(ret2); - for(int i=0;i getQuadraticStatus() const; - DataArrayInt *findCellIdsOnBoundary() const; + DataArrayIdType *findCellIdsOnBoundary() const; MEDCouplingUMesh *computeSkin() const; bool checkConsecutiveCellTypes() const; bool checkConsecutiveCellTypesForMEDFileFrmt() const; - DataArrayInt *rearrange2ConsecutiveCellTypes(); - DataArrayInt *sortCellsInMEDFileFrmt(); - DataArrayInt *getRenumArrForMEDFileFrmt() const; - DataArrayInt *convertCellArrayPerGeoType(const DataArrayInt *da) const; - MEDCouplingUMesh *buildDescendingConnectivity(DataArrayInt *desc, DataArrayInt *descIndx, DataArrayInt *revDesc, DataArrayInt *revDescIndx) const; - MEDCouplingUMesh *buildDescendingConnectivity2(DataArrayInt *desc, DataArrayInt *descIndx, DataArrayInt *revDesc, DataArrayInt *revDescIndx) const; - MEDCouplingUMesh *explode3DMeshTo1D(DataArrayInt *desc, DataArrayInt *descIndx, DataArrayInt *revDesc, DataArrayInt *revDescIndx) const; - MEDCouplingUMesh *explodeMeshIntoMicroEdges(DataArrayInt *desc, DataArrayInt *descIndx, DataArrayInt *revDesc, DataArrayInt *revDescIndx) const; + DataArrayIdType *rearrange2ConsecutiveCellTypes(); + DataArrayIdType *sortCellsInMEDFileFrmt(); + DataArrayIdType *getRenumArrForMEDFileFrmt() const; + DataArrayIdType *convertCellArrayPerGeoType(const DataArrayIdType *da) const; + MEDCouplingUMesh *buildDescendingConnectivity(DataArrayIdType *desc, DataArrayIdType *descIndx, DataArrayIdType *revDesc, DataArrayIdType *revDescIndx) const; + MEDCouplingUMesh *buildDescendingConnectivity2(DataArrayIdType *desc, DataArrayIdType *descIndx, DataArrayIdType *revDesc, DataArrayIdType *revDescIndx) const; + MEDCouplingUMesh *explode3DMeshTo1D(DataArrayIdType *desc, DataArrayIdType *descIndx, DataArrayIdType *revDesc, DataArrayIdType *revDescIndx) const; + MEDCouplingUMesh *explodeMeshIntoMicroEdges(DataArrayIdType *desc, DataArrayIdType *descIndx, DataArrayIdType *revDesc, DataArrayIdType *revDescIndx) const; void orientCorrectlyPolyhedrons(); bool isPresenceOfQuadratic() const; bool isFullyQuadratic() const; @@ -1979,9 +2085,9 @@ namespace MEDCoupling bool isContiguous1D() const; void tessellate2D(double eps); void convertQuadraticCellsToLinear(); - DataArrayInt *convertLinearCellsToQuadratic(int conversionType=0); + DataArrayIdType *convertLinearCellsToQuadratic(int conversionType=0); void convertDegeneratedCells(); - DataArrayInt *convertDegeneratedCellsAndRemoveFlatOnes(); + DataArrayIdType *convertDegeneratedCellsAndRemoveFlatOnes(); bool removeDegenerated1DCells(); bool areOnlySimplexCells() const; MEDCouplingFieldDouble *getEdgeRatioField() const; @@ -1989,27 +2095,27 @@ namespace MEDCoupling MEDCouplingFieldDouble *getWarpField() const; MEDCouplingFieldDouble *getSkewField() const; DataArrayDouble *computePlaneEquationOf3DFaces() const; - DataArrayInt *convexEnvelop2D(); + DataArrayIdType *convexEnvelop2D(); std::string cppRepr() const; - DataArrayInt *findAndCorrectBadOriented3DExtrudedCells(); - DataArrayInt *findAndCorrectBadOriented3DCells(); + DataArrayIdType *findAndCorrectBadOriented3DExtrudedCells(); + DataArrayIdType *findAndCorrectBadOriented3DCells(); MEDCoupling::MEDCoupling1GTUMesh *convertIntoSingleGeoTypeMesh() const; MEDCouplingSkyLineArray *generateGraph() const; - DataArrayInt *convertNodalConnectivityToStaticGeoTypeMesh() const; - DataArrayInt *buildUnionOf2DMesh() const; - DataArrayInt *buildUnionOf3DMesh() const; - DataArrayInt *orderConsecutiveCells1D() const; + DataArrayIdType *convertNodalConnectivityToStaticGeoTypeMesh() const; + DataArrayIdType *buildUnionOf2DMesh() const; + DataArrayIdType *buildUnionOf3DMesh() const; + DataArrayIdType *orderConsecutiveCells1D() const; DataArrayDouble *getBoundingBoxForBBTreeFast() const; DataArrayDouble *getBoundingBoxForBBTree2DQuadratic(double arcDetEps=1e-12) const; DataArrayDouble *getBoundingBoxForBBTree1DQuadratic(double arcDetEps=1e-12) const; void changeOrientationOfCells(); DataArrayDouble *computeCellCenterOfMassWithPrecision(double eps); - int split2DCells(const DataArrayInt *desc, const DataArrayInt *descI, const DataArrayInt *subNodesInSeg, const DataArrayInt *subNodesInSegI, const DataArrayInt *midOpt=0, const DataArrayInt *midOptI=0); + int split2DCells(const DataArrayIdType *desc, const DataArrayIdType *descI, const DataArrayIdType *subNodesInSeg, const DataArrayIdType *subNodesInSegI, const DataArrayIdType *midOpt=0, const DataArrayIdType *midOptI=0); static MEDCouplingUMesh *Build0DMeshFromCoords(DataArrayDouble *da); static MEDCouplingUMesh *MergeUMeshes(const MEDCouplingUMesh *mesh1, const MEDCouplingUMesh *mesh2); static MEDCouplingUMesh *MergeUMeshesOnSameCoords(const MEDCouplingUMesh *mesh1, const MEDCouplingUMesh *mesh2); - static DataArrayInt *ComputeSpreadZoneGradually(const DataArrayInt *arrIn, const DataArrayInt *arrIndxIn); - static DataArrayInt *ComputeRangesFromTypeDistribution(const std::vector& code); + static DataArrayIdType *ComputeSpreadZoneGradually(const DataArrayIdType *arrIn, const DataArrayIdType *arrIndxIn); + static DataArrayIdType *ComputeRangesFromTypeDistribution(const std::vector& code); %extend { MEDCouplingUMesh() { @@ -2056,12 +2162,12 @@ namespace MEDCoupling void setPartOfMySelf(PyObject *li, const MEDCouplingUMesh& otherOnSameCoordsThanThis) { - int sw; - int singleVal; - std::vector multiVal; - std::pair > slic; - MEDCoupling::DataArrayInt *daIntTyypp=0; - int nbc=self->getNumberOfCells(); + mcIdType sw; + mcIdType singleVal; + std::vector multiVal; + std::pair > slic; + MEDCoupling::DataArrayIdType *daIntTyypp=0; + mcIdType nbc=self->getNumberOfCells(); convertIntStarOrSliceLikePyObjToCpp(li,nbc,sw,singleVal,multiVal,slic,daIntTyypp); switch(sw) { @@ -2082,7 +2188,7 @@ namespace MEDCoupling { if(nbc+singleVal>0) { - int tmp=nbc+singleVal; + mcIdType tmp=nbc+singleVal; self->setPartOfMySelf(&tmp,&tmp+1,otherOnSameCoordsThanThis); break; } @@ -2108,18 +2214,18 @@ namespace MEDCoupling break; } default: - throw INTERP_KERNEL::Exception("MEDCouplingUMesh::setPartOfMySelf : unrecognized type in input ! Possibilities are : int, list or tuple of int DataArrayInt instance !"); + throw INTERP_KERNEL::Exception("MEDCouplingUMesh::setPartOfMySelf : unrecognized type in input ! Possibilities are : int, list or tuple of int DataArrayIdType instance !"); } } void __setitem__(PyObject *li, const MEDCouplingUMesh& otherOnSameCoordsThanThis) { - int sw; - int singleVal; - std::vector multiVal; - std::pair > slic; - MEDCoupling::DataArrayInt *daIntTyypp=0; - int nbc=self->getNumberOfCells(); + mcIdType sw; + mcIdType singleVal; + std::vector multiVal; + std::pair > slic; + MEDCoupling::DataArrayIdType *daIntTyypp=0; + mcIdType nbc=self->getNumberOfCells(); convertIntStarOrSliceLikePyObjToCpp(li,nbc,sw,singleVal,multiVal,slic,daIntTyypp); switch(sw) { @@ -2140,7 +2246,7 @@ namespace MEDCoupling { if(nbc+singleVal>0) { - int tmp=nbc+singleVal; + mcIdType tmp=nbc+singleVal; self->setPartOfMySelf(&tmp,&tmp+1,otherOnSameCoordsThanThis); break; } @@ -2171,15 +2277,15 @@ namespace MEDCoupling break; } default: - throw INTERP_KERNEL::Exception("MEDCouplingUMesh::__setitem__ : unrecognized type in input ! Possibilities are : int, list or tuple of int, slice, DataArrayInt instance !"); + throw INTERP_KERNEL::Exception("MEDCouplingUMesh::__setitem__ : unrecognized type in input ! Possibilities are : int, list or tuple of int, slice, DataArrayIdType instance !"); } } - void insertNextCell(INTERP_KERNEL::NormalizedCellType type, int size, PyObject *li) + void insertNextCell(INTERP_KERNEL::NormalizedCellType type, mcIdType size, PyObject *li) { - int szArr,sw,iTypppArr; - std::vector stdvecTyyppArr; - const int *tmp=convertIntStarLikePyObjToCppIntStar(li,sw,szArr,iTypppArr,stdvecTyyppArr); + mcIdType szArr,sw,iTypppArr; + std::vector stdvecTyyppArr; + const mcIdType *tmp=convertIntStarLikePyObjToCppIntStar(li,sw,szArr,iTypppArr,stdvecTyyppArr); if(size>szArr) { std::ostringstream oss; oss << "Wrap of MEDCouplingUMesh::insertNextCell : request of connectivity with length " << size << " whereas the length of input is " << szArr << " !"; @@ -2190,47 +2296,47 @@ namespace MEDCoupling void insertNextCell(INTERP_KERNEL::NormalizedCellType type, PyObject *li) { - int szArr,sw,iTypppArr; - std::vector stdvecTyyppArr; - const int *tmp=convertIntStarLikePyObjToCppIntStar(li,sw,szArr,iTypppArr,stdvecTyyppArr); + mcIdType szArr,sw,iTypppArr; + std::vector stdvecTyyppArr; + const mcIdType *tmp=convertIntStarLikePyObjToCppIntStar(li,sw,szArr,iTypppArr,stdvecTyyppArr); self->insertNextCell(type,szArr,tmp); } - DataArrayInt *getNodalConnectivity() + DataArrayIdType *getNodalConnectivity() { - DataArrayInt *ret=self->getNodalConnectivity(); + DataArrayIdType *ret=self->getNodalConnectivity(); if(ret) ret->incrRef(); return ret; } - DataArrayInt *getNodalConnectivityIndex() + DataArrayIdType *getNodalConnectivityIndex() { - DataArrayInt *ret=self->getNodalConnectivityIndex(); + DataArrayIdType *ret=self->getNodalConnectivityIndex(); if(ret) ret->incrRef(); return ret; } - static PyObject *ComputeSpreadZoneGraduallyFromSeed(PyObject *seed, const DataArrayInt *arrIn, const DataArrayInt *arrIndxIn, int nbOfDepthPeeling=-1) + static PyObject *ComputeSpreadZoneGraduallyFromSeed(PyObject *seed, const DataArrayIdType *arrIn, const DataArrayIdType *arrIndxIn, mcIdType nbOfDepthPeeling=-1) { - int szArr,sw,iTypppArr; - std::vector stdvecTyyppArr; - const int *seedPtr=convertIntStarLikePyObjToCppIntStar(seed,sw,szArr,iTypppArr,stdvecTyyppArr); - int nbOfDepthPeelingPerformed=0; - DataArrayInt *ret0=MEDCouplingUMesh::ComputeSpreadZoneGraduallyFromSeed(seedPtr,seedPtr+szArr,arrIn,arrIndxIn,nbOfDepthPeeling,nbOfDepthPeelingPerformed); + mcIdType szArr,sw,iTypppArr; + std::vector stdvecTyyppArr; + const mcIdType *seedPtr=convertIntStarLikePyObjToCppIntStar(seed,sw,szArr,iTypppArr,stdvecTyyppArr); + mcIdType nbOfDepthPeelingPerformed=0; + DataArrayIdType *ret0=MEDCouplingUMesh::ComputeSpreadZoneGraduallyFromSeed(seedPtr,seedPtr+szArr,arrIn,arrIndxIn,nbOfDepthPeeling,nbOfDepthPeelingPerformed); PyObject *res=PyTuple_New(2); - PyTuple_SetItem(res,0,SWIG_NewPointerObj(SWIG_as_voidptr(ret0),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(res,0,SWIG_NewPointerObj(SWIG_as_voidptr(ret0),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); PyTuple_SetItem(res,1,PyInt_FromLong(nbOfDepthPeelingPerformed)); return res; } - static PyObject *FindCommonCellsAlg(int compType, int startCellId, const DataArrayInt *nodal, const DataArrayInt *nodalI, const DataArrayInt *revNodal, const DataArrayInt *revNodalI) + static PyObject *FindCommonCellsAlg(int compType, mcIdType startCellId, const DataArrayIdType *nodal, const DataArrayIdType *nodalI, const DataArrayIdType *revNodal, const DataArrayIdType *revNodalI) { - DataArrayInt *v0=0,*v1=0; + DataArrayIdType *v0=0,*v1=0; MEDCouplingUMesh::FindCommonCellsAlg(compType,startCellId,nodal,nodalI,revNodal,revNodalI,v0,v1); PyObject *res = PyList_New(2); - PyList_SetItem(res,0,SWIG_NewPointerObj(SWIG_as_voidptr(v0),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyList_SetItem(res,1,SWIG_NewPointerObj(SWIG_as_voidptr(v1),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyList_SetItem(res,0,SWIG_NewPointerObj(SWIG_as_voidptr(v0),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); + PyList_SetItem(res,1,SWIG_NewPointerObj(SWIG_as_voidptr(v1),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); return res; } @@ -2240,11 +2346,11 @@ namespace MEDCoupling DataArrayDouble *a; DataArrayDoubleTuple *aa; std::vector bb; - int sw; + mcIdType sw; int nbOfCompo=self->getSpaceDimension(); const double *pt=convertObjToPossibleCpp5_Safe(point,sw,val,a,aa,bb,"Python wrap of MEDCouplingUMesh::distanceToPoint",1,nbOfCompo,true); // - int cellId=-1; + mcIdType cellId=-1; double ret0=self->distanceToPoint(pt,pt+nbOfCompo,cellId); PyObject *ret=PyTuple_New(2); PyTuple_SetItem(ret,0,PyFloat_FromDouble(ret0)); @@ -2254,118 +2360,118 @@ namespace MEDCoupling PyObject *distanceToPoints(const DataArrayDouble *pts) const { - DataArrayInt *ret1=0; + DataArrayIdType *ret1=0; DataArrayDouble *ret0=self->distanceToPoints(pts,ret1); PyObject *ret=PyTuple_New(2); PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(ret0),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); return ret; } PyObject *tetrahedrize(int policy) { - int ret2(-1); - DataArrayInt *ret1(0); + mcIdType ret2(-1); + DataArrayIdType *ret1(0); MEDCoupling1SGTUMesh *ret0(self->tetrahedrize(policy,ret1,ret2)); PyObject *ret=PyTuple_New(3); PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(ret0),SWIGTYPE_p_MEDCoupling__MEDCoupling1SGTUMesh, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); PyTuple_SetItem(ret,2,PyInt_FromLong(ret2)); return ret; } PyObject *checkButterflyCells(double eps=1e-12) { - std::vector cells; + std::vector cells; self->checkButterflyCells(cells,eps); - DataArrayInt *ret=DataArrayInt::New(); - ret->alloc((int)cells.size(),1); + DataArrayIdType *ret=DataArrayIdType::New(); + ret->alloc(cells.size(),1); std::copy(cells.begin(),cells.end(),ret->getPointer()); - return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 ); + return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 ); } PyObject *splitByType() const { std::vector ms=self->splitByType(); - int sz=ms.size(); + std::size_t sz=ms.size(); PyObject *ret = PyList_New(sz); - for(int i=0;i retCpp=self->partitionBySpreadZone(); - int sz=retCpp.size(); + std::vector retCpp=self->partitionBySpreadZone(); + std::size_t sz=retCpp.size(); PyObject *ret=PyList_New(sz); - for(int i=0;i::TI, SWIG_POINTER_OWN | 0 )); return ret; } - static PyObject *PartitionBySpreadZone(const DataArrayInt *arrIn, const DataArrayInt *arrIndxIn) + static PyObject *PartitionBySpreadZone(const DataArrayIdType *arrIn, const DataArrayIdType *arrIndxIn) { - std::vector retCpp(MEDCouplingUMesh::PartitionBySpreadZone(arrIn,arrIndxIn)); - int sz=retCpp.size(); + std::vector retCpp(MEDCouplingUMesh::PartitionBySpreadZone(arrIn,arrIndxIn)); + std::size_t sz=retCpp.size(); PyObject *ret=PyList_New(sz); - for(int i=0;i::TI, SWIG_POINTER_OWN | 0 )); return ret; } PyObject *keepSpecifiedCells(INTERP_KERNEL::NormalizedCellType type, PyObject *ids) const { - int size; - INTERP_KERNEL::AutoPtr tmp=convertPyToNewIntArr2(ids,&size); + mcIdType size; + INTERP_KERNEL::AutoPtr tmp=convertPyToNewIntArr2(ids,&size); MEDCouplingUMesh *ret=self->keepSpecifiedCells(type,tmp,tmp+size); return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_MEDCoupling__MEDCouplingUMesh, SWIG_POINTER_OWN | 0 ); } bool checkConsecutiveCellTypesAndOrder(PyObject *li) const { - int sz; - INTERP_KERNEL::AutoPtr order=(INTERP_KERNEL::NormalizedCellType *)convertPyToNewIntArr2(li,&sz); + mcIdType sz; + INTERP_KERNEL::AutoPtr order=convertPyToNewIntArr2(li,&sz); bool ret=self->checkConsecutiveCellTypesAndOrder(order,order+sz); return ret; } - DataArrayInt *getRenumArrForConsecutiveCellTypesSpec(PyObject *li) const + DataArrayIdType *getRenumArrForConsecutiveCellTypesSpec(PyObject *li) const { - int sz; - INTERP_KERNEL::AutoPtr order=(INTERP_KERNEL::NormalizedCellType *)convertPyToNewIntArr2(li,&sz); - DataArrayInt *ret=self->getRenumArrForConsecutiveCellTypesSpec(order,(INTERP_KERNEL::NormalizedCellType *)order+sz); + mcIdType sz; + INTERP_KERNEL::AutoPtr order=convertPyToNewIntArr2(li,&sz); + DataArrayIdType *ret=self->getRenumArrForConsecutiveCellTypesSpec(order,(INTERP_KERNEL::NormalizedCellType *)order+sz); return ret; } PyObject *findNodesToDuplicate(const MEDCouplingUMesh& otherDimM1OnSameCoords) const { - DataArrayInt *tmp0=0,*tmp1=0,*tmp2=0; + DataArrayIdType *tmp0=0,*tmp1=0,*tmp2=0; self->findNodesToDuplicate(otherDimM1OnSameCoords,tmp0,tmp1,tmp2); PyObject *ret=PyTuple_New(3); - PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(tmp0),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(tmp1),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,2,SWIG_NewPointerObj(SWIG_as_voidptr(tmp2),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(tmp0),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(tmp1),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,2,SWIG_NewPointerObj(SWIG_as_voidptr(tmp2),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); return ret; } PyObject *findCellIdsLyingOn(const MEDCouplingUMesh& otherDimM1OnSameCoords) const { - DataArrayInt *tmp0=0,*tmp1=0; + DataArrayIdType *tmp0=0,*tmp1=0; self->findCellIdsLyingOn(otherDimM1OnSameCoords,tmp0,tmp1); PyObject *ret=PyTuple_New(2); - PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(tmp0),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(tmp1),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(tmp0),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(tmp1),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); return ret; } void duplicateNodes(PyObject *li) { - int sw; - int singleVal; - std::vector multiVal; - std::pair > slic; - MEDCoupling::DataArrayInt *daIntTyypp=0; + mcIdType sw; + mcIdType singleVal; + std::vector multiVal; + std::pair > slic; + MEDCoupling::DataArrayIdType *daIntTyypp=0; convertIntStarOrSliceLikePyObjToCpp(li,self->getNumberOfNodes(),sw,singleVal,multiVal,slic,daIntTyypp); switch(sw) { @@ -2376,17 +2482,17 @@ namespace MEDCoupling case 4: return self->duplicateNodes(daIntTyypp->begin(),daIntTyypp->end()); default: - throw INTERP_KERNEL::Exception("MEDCouplingUMesh::duplicateNodes : unrecognized type entered, expected list of int, tuple of int or DataArrayInt !"); + throw INTERP_KERNEL::Exception("MEDCouplingUMesh::duplicateNodes : unrecognized type entered, expected list of int, tuple of int or DataArrayIdType !"); } } - void duplicateNodesInConn(PyObject *li, int offset) + void duplicateNodesInConn(PyObject *li, mcIdType offset) { - int sw; - int singleVal; - std::vector multiVal; - std::pair > slic; - MEDCoupling::DataArrayInt *daIntTyypp=0; + mcIdType sw; + mcIdType singleVal; + std::vector multiVal; + std::pair > slic; + MEDCoupling::DataArrayIdType *daIntTyypp=0; convertIntStarOrSliceLikePyObjToCpp(li,self->getNumberOfNodes(),sw,singleVal,multiVal,slic,daIntTyypp); switch(sw) { @@ -2397,37 +2503,37 @@ namespace MEDCoupling case 4: return self->duplicateNodesInConn(daIntTyypp->begin(),daIntTyypp->end(),offset); default: - throw INTERP_KERNEL::Exception("MEDCouplingUMesh::duplicateNodesInConn : unrecognized type entered, expected list of int, tuple of int or DataArrayInt !"); + throw INTERP_KERNEL::Exception("MEDCouplingUMesh::duplicateNodesInConn : unrecognized type entered, expected list of int, tuple of int or DataArrayIdType !"); } } void attractSeg3MidPtsAroundNodes(double ratio, PyObject *nodeIds) { - int szArr,sw,iTypppArr; - std::vector stdvecTyyppArr; - const int *nodeIdsPtr(convertIntStarLikePyObjToCppIntStar(nodeIds,sw,szArr,iTypppArr,stdvecTyyppArr)); + mcIdType szArr,sw,iTypppArr; + std::vector stdvecTyyppArr; + const mcIdType *nodeIdsPtr(convertIntStarLikePyObjToCppIntStar(nodeIds,sw,szArr,iTypppArr,stdvecTyyppArr)); self->attractSeg3MidPtsAroundNodes(ratio,nodeIdsPtr,nodeIdsPtr+szArr); } PyObject *getLevArrPerCellTypes(PyObject *li) const { - int sz; - INTERP_KERNEL::AutoPtr order=(INTERP_KERNEL::NormalizedCellType *)convertPyToNewIntArr2(li,&sz); - DataArrayInt *tmp0,*tmp1=0; + mcIdType sz; + INTERP_KERNEL::AutoPtr order=convertPyToNewIntArr2(li,&sz); + DataArrayIdType *tmp0,*tmp1=0; tmp0=self->getLevArrPerCellTypes(order,(INTERP_KERNEL::NormalizedCellType *)order+sz,tmp1); PyObject *ret=PyTuple_New(2); - PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(tmp0),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(tmp1),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(tmp0),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(tmp1),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); return ret; } PyObject *convertNodalConnectivityToDynamicGeoTypeMesh() const { - DataArrayInt *ret0=0,*ret1=0; + DataArrayIdType *ret0=0,*ret1=0; self->convertNodalConnectivityToDynamicGeoTypeMesh(ret0,ret1); PyObject *ret=PyTuple_New(2); - PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(ret0),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(ret0),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); return ret; } @@ -2435,12 +2541,12 @@ namespace MEDCoupling { std::vector meshes; convertFromPyObjVectorOfObj(ms,SWIGTYPE_p_MEDCoupling__MEDCouplingUMesh,"MEDCouplingUMesh",meshes); - DataArrayInt *ret1=0,*ret2=0; + DataArrayIdType *ret1=0,*ret2=0; MEDCouplingUMesh *ret0=MEDCouplingUMesh::AggregateSortedByTypeMeshesOnSameCoords(meshes,ret1,ret2); PyObject *ret=PyTuple_New(3); PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(ret0),SWIGTYPE_p_MEDCoupling__MEDCouplingUMesh, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,2,SWIG_NewPointerObj(SWIG_as_voidptr(ret2),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,2,SWIG_NewPointerObj(SWIG_as_voidptr(ret2),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); return ret; } @@ -2454,15 +2560,15 @@ namespace MEDCoupling static PyObject *FuseUMeshesOnSameCoords(PyObject *ms, int compType) { - int sz; + std::size_t sz; std::vector meshes; convertFromPyObjVectorOfObj(ms,SWIGTYPE_p_MEDCoupling__MEDCouplingUMesh,"MEDCouplingUMesh",meshes); - std::vector corr; + std::vector corr; MEDCouplingUMesh *um=MEDCouplingUMesh::FuseUMeshesOnSameCoords(meshes,compType,corr); sz=corr.size(); PyObject *ret1=PyList_New(sz); - for(int i=0;i::TI, SWIG_POINTER_OWN | 0 )); PyObject *ret=PyList_New(2); PyList_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(um),SWIGTYPE_p_MEDCoupling__MEDCouplingUMesh, SWIG_POINTER_OWN | 0 )); PyList_SetItem(ret,1,ret1); @@ -2489,17 +2595,17 @@ namespace MEDCoupling DataArrayDouble *a; DataArrayDoubleTuple *aa; std::vector bb; - int sw; + mcIdType sw; int spaceDim=self->getSpaceDimension(); const char msg[]="Python wrap of MEDCouplingUMesh::are2DCellsNotCorrectlyOriented : "; const double *v=convertObjToPossibleCpp5_Safe(vec,sw,val,a,aa,bb,msg,1,spaceDim,true); // - std::vector cells; + std::vector cells; self->are2DCellsNotCorrectlyOriented(v,polyOnly,cells); - DataArrayInt *ret=DataArrayInt::New(); - ret->alloc((int)cells.size(),1); + DataArrayIdType *ret=DataArrayIdType::New(); + ret->alloc(cells.size(),1); std::copy(cells.begin(),cells.end(),ret->getPointer()); - return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 ); + return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 ); } void orientCorrectly2DCells(PyObject *vec, bool polyOnly) @@ -2508,7 +2614,7 @@ namespace MEDCoupling DataArrayDouble *a; DataArrayDoubleTuple *aa; std::vector bb; - int sw; + mcIdType sw; int spaceDim=self->getSpaceDimension(); const char msg[]="Python wrap of MEDCouplingUMesh::orientCorrectly2DCells : "; const double *v=convertObjToPossibleCpp5_Safe(vec,sw,val,a,aa,bb,msg,1,spaceDim,true); @@ -2517,12 +2623,12 @@ namespace MEDCoupling PyObject *arePolyhedronsNotCorrectlyOriented() const { - std::vector cells; + std::vector cells; self->arePolyhedronsNotCorrectlyOriented(cells); - DataArrayInt *ret=DataArrayInt::New(); - ret->alloc((int)cells.size(),1); + DataArrayIdType *ret=DataArrayIdType::New(); + ret->alloc(cells.size(),1); std::copy(cells.begin(),cells.end(),ret->getPointer()); - return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 ); + return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 ); } PyObject *getFastAveragePlaneOfThis() const @@ -2545,200 +2651,200 @@ namespace MEDCoupling PyObject *areCellsIncludedIn(const MEDCouplingUMesh *other, int compType) const { - DataArrayInt *ret1; + DataArrayIdType *ret1; bool ret0=self->areCellsIncludedIn(other,compType,ret1); PyObject *ret=PyTuple_New(2); PyObject *ret0Py=ret0?Py_True:Py_False; Py_XINCREF(ret0Py); PyTuple_SetItem(ret,0,ret0Py); - PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); return ret; } PyObject *areCellsIncludedInPolicy7(const MEDCouplingUMesh *other) const { - DataArrayInt *ret1; + DataArrayIdType *ret1; bool ret0=self->areCellsIncludedInPolicy7(other,ret1); PyObject *ret=PyTuple_New(2); PyObject *ret0Py=ret0?Py_True:Py_False; Py_XINCREF(ret0Py); PyTuple_SetItem(ret,0,ret0Py); - PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); return ret; } PyObject *explode3DMeshTo1D() const { - MCAuto d0=DataArrayInt::New(); - MCAuto d1=DataArrayInt::New(); - MCAuto d2=DataArrayInt::New(); - MCAuto d3=DataArrayInt::New(); + MCAuto d0=DataArrayIdType::New(); + MCAuto d1=DataArrayIdType::New(); + MCAuto d2=DataArrayIdType::New(); + MCAuto d3=DataArrayIdType::New(); MEDCouplingUMesh *m=self->explode3DMeshTo1D(d0,d1,d2,d3); PyObject *ret=PyTuple_New(5); PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(m),SWIGTYPE_p_MEDCoupling__MEDCouplingUMesh, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(d0.retn()),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,2,SWIG_NewPointerObj(SWIG_as_voidptr(d1.retn()),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,3,SWIG_NewPointerObj(SWIG_as_voidptr(d2.retn()),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,4,SWIG_NewPointerObj(SWIG_as_voidptr(d3.retn()),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(d0.retn()),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,2,SWIG_NewPointerObj(SWIG_as_voidptr(d1.retn()),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,3,SWIG_NewPointerObj(SWIG_as_voidptr(d2.retn()),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,4,SWIG_NewPointerObj(SWIG_as_voidptr(d3.retn()),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); return ret; } PyObject *explodeIntoEdges() const { - MCAuto desc,descIndex,revDesc,revDescIndx; + MCAuto desc,descIndex,revDesc,revDescIndx; MCAuto m(self->explodeIntoEdges(desc,descIndex,revDesc,revDescIndx)); PyObject *ret=PyTuple_New(5); PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(m.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingUMesh, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(desc.retn()),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,2,SWIG_NewPointerObj(SWIG_as_voidptr(descIndex.retn()),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,3,SWIG_NewPointerObj(SWIG_as_voidptr(revDesc.retn()),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,4,SWIG_NewPointerObj(SWIG_as_voidptr(revDescIndx.retn()),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(desc.retn()),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,2,SWIG_NewPointerObj(SWIG_as_voidptr(descIndex.retn()),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,3,SWIG_NewPointerObj(SWIG_as_voidptr(revDesc.retn()),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,4,SWIG_NewPointerObj(SWIG_as_voidptr(revDescIndx.retn()),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); return ret; } PyObject *explodeMeshIntoMicroEdges() const { - MCAuto d0=DataArrayInt::New(); - MCAuto d1=DataArrayInt::New(); - MCAuto d2=DataArrayInt::New(); - MCAuto d3=DataArrayInt::New(); + MCAuto d0=DataArrayIdType::New(); + MCAuto d1=DataArrayIdType::New(); + MCAuto d2=DataArrayIdType::New(); + MCAuto d3=DataArrayIdType::New(); MEDCouplingUMesh *m=self->explodeMeshIntoMicroEdges(d0,d1,d2,d3); PyObject *ret=PyTuple_New(5); PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(m),SWIGTYPE_p_MEDCoupling__MEDCouplingUMesh, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(d0.retn()),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,2,SWIG_NewPointerObj(SWIG_as_voidptr(d1.retn()),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,3,SWIG_NewPointerObj(SWIG_as_voidptr(d2.retn()),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,4,SWIG_NewPointerObj(SWIG_as_voidptr(d3.retn()),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(d0.retn()),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,2,SWIG_NewPointerObj(SWIG_as_voidptr(d1.retn()),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,3,SWIG_NewPointerObj(SWIG_as_voidptr(d2.retn()),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,4,SWIG_NewPointerObj(SWIG_as_voidptr(d3.retn()),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); return ret; } PyObject *buildDescendingConnectivity() const { - MCAuto d0=DataArrayInt::New(); - MCAuto d1=DataArrayInt::New(); - MCAuto d2=DataArrayInt::New(); - MCAuto d3=DataArrayInt::New(); + MCAuto d0=DataArrayIdType::New(); + MCAuto d1=DataArrayIdType::New(); + MCAuto d2=DataArrayIdType::New(); + MCAuto d3=DataArrayIdType::New(); MEDCouplingUMesh *m=self->buildDescendingConnectivity(d0,d1,d2,d3); PyObject *ret=PyTuple_New(5); PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(m),SWIGTYPE_p_MEDCoupling__MEDCouplingUMesh, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(d0.retn()),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,2,SWIG_NewPointerObj(SWIG_as_voidptr(d1.retn()),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,3,SWIG_NewPointerObj(SWIG_as_voidptr(d2.retn()),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,4,SWIG_NewPointerObj(SWIG_as_voidptr(d3.retn()),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(d0.retn()),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,2,SWIG_NewPointerObj(SWIG_as_voidptr(d1.retn()),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,3,SWIG_NewPointerObj(SWIG_as_voidptr(d2.retn()),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,4,SWIG_NewPointerObj(SWIG_as_voidptr(d3.retn()),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); return ret; } PyObject *buildDescendingConnectivity2() const { - MCAuto d0=DataArrayInt::New(); - MCAuto d1=DataArrayInt::New(); - MCAuto d2=DataArrayInt::New(); - MCAuto d3=DataArrayInt::New(); + MCAuto d0=DataArrayIdType::New(); + MCAuto d1=DataArrayIdType::New(); + MCAuto d2=DataArrayIdType::New(); + MCAuto d3=DataArrayIdType::New(); MEDCouplingUMesh *m=self->buildDescendingConnectivity2(d0,d1,d2,d3); PyObject *ret=PyTuple_New(5); PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(m),SWIGTYPE_p_MEDCoupling__MEDCouplingUMesh, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(d0.retn()),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,2,SWIG_NewPointerObj(SWIG_as_voidptr(d1.retn()),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,3,SWIG_NewPointerObj(SWIG_as_voidptr(d2.retn()),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,4,SWIG_NewPointerObj(SWIG_as_voidptr(d3.retn()),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(d0.retn()),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,2,SWIG_NewPointerObj(SWIG_as_voidptr(d1.retn()),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,3,SWIG_NewPointerObj(SWIG_as_voidptr(d2.retn()),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,4,SWIG_NewPointerObj(SWIG_as_voidptr(d3.retn()),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); return ret; } PyObject *computeNeighborsOfCells() const { - DataArrayInt *neighbors=0,*neighborsIdx=0; + DataArrayIdType *neighbors=0,*neighborsIdx=0; self->computeNeighborsOfCells(neighbors,neighborsIdx); PyObject *ret=PyTuple_New(2); - PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(neighbors),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(neighborsIdx),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(neighbors),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(neighborsIdx),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); return ret; } PyObject *computeNeighborsOfNodes() const { - DataArrayInt *neighbors=0,*neighborsIdx=0; + DataArrayIdType *neighbors=0,*neighborsIdx=0; self->computeNeighborsOfNodes(neighbors,neighborsIdx); PyObject *ret=PyTuple_New(2); - PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(neighbors),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(neighborsIdx),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(neighbors),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(neighborsIdx),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); return ret; } PyObject *computeEnlargedNeighborsOfNodes() const { - MCAuto neighbors,neighborsIdx; + MCAuto neighbors,neighborsIdx; self->computeEnlargedNeighborsOfNodes(neighbors,neighborsIdx); PyObject *ret=PyTuple_New(2); - PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(neighbors.retn()),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(neighborsIdx.retn()),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(neighbors.retn()),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(neighborsIdx.retn()),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); return ret; } - PyObject *computeCellNeighborhoodFromNodesOne(const DataArrayInt *nodeNeigh, const DataArrayInt *nodeNeighI) const + PyObject *computeCellNeighborhoodFromNodesOne(const DataArrayIdType *nodeNeigh, const DataArrayIdType *nodeNeighI) const { - MCAuto cellNeigh,cellNeighIndex; + MCAuto cellNeigh,cellNeighIndex; self->computeCellNeighborhoodFromNodesOne(nodeNeigh,nodeNeighI,cellNeigh,cellNeighIndex); PyObject *ret=PyTuple_New(2); - PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(cellNeigh.retn()),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(cellNeighIndex.retn()),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(cellNeigh.retn()),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(cellNeighIndex.retn()),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); return ret; } - static PyObject *ComputeNeighborsOfCellsAdv(const DataArrayInt *desc, const DataArrayInt *descI, const DataArrayInt *revDesc, const DataArrayInt *revDescI) + static PyObject *ComputeNeighborsOfCellsAdv(const DataArrayIdType *desc, const DataArrayIdType *descI, const DataArrayIdType *revDesc, const DataArrayIdType *revDescI) { - DataArrayInt *neighbors=0,*neighborsIdx=0; + DataArrayIdType *neighbors=0,*neighborsIdx=0; MEDCouplingUMesh::ComputeNeighborsOfCellsAdv(desc,descI,revDesc,revDescI,neighbors,neighborsIdx); PyObject *ret=PyTuple_New(2); - PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(neighbors),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(neighborsIdx),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(neighbors),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(neighborsIdx),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); return ret; } PyObject *emulateMEDMEMBDC(const MEDCouplingUMesh *nM1LevMesh) { - MCAuto d0=DataArrayInt::New(); - MCAuto d1=DataArrayInt::New(); - DataArrayInt *d2,*d3,*d4,*dd5; + MCAuto d0=DataArrayIdType::New(); + MCAuto d1=DataArrayIdType::New(); + DataArrayIdType *d2,*d3,*d4,*dd5; MEDCouplingUMesh *mOut=self->emulateMEDMEMBDC(nM1LevMesh,d0,d1,d2,d3,d4,dd5); PyObject *ret=PyTuple_New(7); PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(mOut),SWIGTYPE_p_MEDCoupling__MEDCouplingUMesh, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(d0.retn()),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,2,SWIG_NewPointerObj(SWIG_as_voidptr(d1.retn()),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,3,SWIG_NewPointerObj(SWIG_as_voidptr(d2),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,4,SWIG_NewPointerObj(SWIG_as_voidptr(d3),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,5,SWIG_NewPointerObj(SWIG_as_voidptr(d4),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,6,SWIG_NewPointerObj(SWIG_as_voidptr(dd5),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(d0.retn()),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,2,SWIG_NewPointerObj(SWIG_as_voidptr(d1.retn()),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,3,SWIG_NewPointerObj(SWIG_as_voidptr(d2),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,4,SWIG_NewPointerObj(SWIG_as_voidptr(d3),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,5,SWIG_NewPointerObj(SWIG_as_voidptr(d4),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,6,SWIG_NewPointerObj(SWIG_as_voidptr(dd5),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); return ret; } - DataArrayDouble *getPartBarycenterAndOwner(DataArrayInt *da) const + DataArrayDouble *getPartBarycenterAndOwner(DataArrayIdType *da) const { if(!da) - throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !"); + throw INTERP_KERNEL::Exception("Not null DataArrayIdType instance expected !"); da->checkAllocated(); return self->getPartBarycenterAndOwner(da->getConstPointer(),da->getConstPointer()+da->getNbOfElems()); } - DataArrayDouble *getPartMeasureField(bool isAbs, DataArrayInt *da) const + DataArrayDouble *getPartMeasureField(bool isAbs, DataArrayIdType *da) const { if(!da) - throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !"); + throw INTERP_KERNEL::Exception("Not null DataArrayIdType instance expected !"); da->checkAllocated(); return self->getPartMeasureField(isAbs,da->getConstPointer(),da->getConstPointer()+da->getNbOfElems()); } - MEDCouplingFieldDouble *buildPartOrthogonalField(DataArrayInt *da) const + MEDCouplingFieldDouble *buildPartOrthogonalField(DataArrayIdType *da) const { if(!da) - throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !"); + throw INTERP_KERNEL::Exception("Not null DataArrayIdType instance expected !"); da->checkAllocated(); return self->buildPartOrthogonalField(da->getConstPointer(),da->getConstPointer()+da->getNbOfElems()); } - PyObject *getTypesOfPart(DataArrayInt *da) const + PyObject *getTypesOfPart(DataArrayIdType *da) const { if(!da) - throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !"); + throw INTERP_KERNEL::Exception("Not null DataArrayIdType instance expected !"); da->checkAllocated(); std::set result=self->getTypesOfPart(da->getConstPointer(),da->getConstPointer()+da->getNbOfElems()); std::set::const_iterator iL=result.begin(); @@ -2748,37 +2854,37 @@ namespace MEDCoupling return res; } - DataArrayInt *keepCellIdsByType(INTERP_KERNEL::NormalizedCellType type, DataArrayInt *da) const + DataArrayIdType *keepCellIdsByType(INTERP_KERNEL::NormalizedCellType type, DataArrayIdType *da) const { if(!da) - throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !"); + throw INTERP_KERNEL::Exception("Not null DataArrayIdType instance expected !"); da->checkAllocated(); - DataArrayInt *ret=self->keepCellIdsByType(type,da->getConstPointer(),da->getConstPointer()+da->getNbOfElems()); + DataArrayIdType *ret=self->keepCellIdsByType(type,da->getConstPointer(),da->getConstPointer()+da->getNbOfElems()); ret->setName(da->getName().c_str()); return ret; } static PyObject *Intersect2DMeshes(const MEDCouplingUMesh *m1, const MEDCouplingUMesh *m2, double eps) { - DataArrayInt *cellNb1=0,*cellNb2=0; + DataArrayIdType *cellNb1=0,*cellNb2=0; MEDCouplingUMesh *mret=MEDCouplingUMesh::Intersect2DMeshes(m1,m2,eps,cellNb1,cellNb2); PyObject *ret=PyTuple_New(3); PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(mret),SWIGTYPE_p_MEDCoupling__MEDCouplingUMesh, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(cellNb1),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,2,SWIG_NewPointerObj(SWIG_as_voidptr(cellNb2),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(cellNb1),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,2,SWIG_NewPointerObj(SWIG_as_voidptr(cellNb2),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); return ret; } static PyObject *Intersect2DMeshWith1DLine(const MEDCouplingUMesh *mesh2D, const MEDCouplingUMesh *mesh1D, double eps) { MEDCouplingUMesh *splitMesh2D(0),*splitMesh1D(0); - DataArrayInt *cellIdInMesh2D(0),*cellIdInMesh1D(0); + DataArrayIdType *cellIdInMesh2D(0),*cellIdInMesh1D(0); MEDCouplingUMesh::Intersect2DMeshWith1DLine(mesh2D,mesh1D,eps,splitMesh2D,splitMesh1D,cellIdInMesh2D,cellIdInMesh1D); PyObject *ret(PyTuple_New(4)); PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(splitMesh2D),SWIGTYPE_p_MEDCoupling__MEDCouplingUMesh, SWIG_POINTER_OWN | 0 )); PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(splitMesh1D),SWIGTYPE_p_MEDCoupling__MEDCouplingUMesh, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,2,SWIG_NewPointerObj(SWIG_as_voidptr(cellIdInMesh2D),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,3,SWIG_NewPointerObj(SWIG_as_voidptr(cellIdInMesh1D),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,2,SWIG_NewPointerObj(SWIG_as_voidptr(cellIdInMesh2D),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,3,SWIG_NewPointerObj(SWIG_as_voidptr(cellIdInMesh1D),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); return ret; } @@ -2791,17 +2897,17 @@ namespace MEDCoupling DataArrayDouble *a,*a2; DataArrayDoubleTuple *aa,*aa2; std::vector bb,bb2; - int sw; + mcIdType sw; const char msg[]="Python wrap of MEDCouplingUMesh::buildSlice3D : 1st parameter for origin."; const char msg2[]="Python wrap of MEDCouplingUMesh::buildSlice3D : 2nd parameter for vector."; const double *orig=convertObjToPossibleCpp5_Safe(origin,sw,val,a,aa,bb,msg,1,spaceDim,true); const double *vect=convertObjToPossibleCpp5_Safe(vec,sw,val2,a2,aa2,bb2,msg2,1,spaceDim,true); // - DataArrayInt *cellIds=0; + DataArrayIdType *cellIds=0; MEDCouplingUMesh *ret0=self->buildSlice3D(orig,vect,eps,cellIds); PyObject *ret=PyTuple_New(2); PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(ret0),SWIGTYPE_p_MEDCoupling__MEDCouplingUMesh, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(cellIds),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(cellIds),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); return ret; } @@ -2814,17 +2920,17 @@ namespace MEDCoupling DataArrayDouble *a,*a2; DataArrayDoubleTuple *aa,*aa2; std::vector bb,bb2; - int sw; + mcIdType sw; const char msg[]="Python wrap of MEDCouplingUMesh::buildSlice3DSurf : 1st parameter for origin."; const char msg2[]="Python wrap of MEDCouplingUMesh::buildSlice3DSurf : 2nd parameter for vector."; const double *orig=convertObjToPossibleCpp5_Safe(origin,sw,val,a,aa,bb,msg,1,spaceDim,true); const double *vect=convertObjToPossibleCpp5_Safe(vec,sw,val2,a2,aa2,bb2,msg2,1,spaceDim,true); // - DataArrayInt *cellIds=0; + DataArrayIdType *cellIds=0; MEDCouplingUMesh *ret0=self->buildSlice3DSurf(orig,vect,eps,cellIds); PyObject *ret=PyTuple_New(2); PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(ret0),SWIGTYPE_p_MEDCoupling__MEDCouplingUMesh, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(cellIds),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(cellIds),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); return ret; } @@ -2834,7 +2940,7 @@ namespace MEDCoupling DataArrayDouble *a,*a2; DataArrayDoubleTuple *aa,*aa2; std::vector bb,bb2; - int sw; + mcIdType sw; const char msg[]="Python wrap of MEDCouplingUMesh::clipSingle3DCellByPlane : 1st parameter for origin."; const char msg2[]="Python wrap of MEDCouplingUMesh::clipSingle3DCellByPlane : 2nd parameter for vector."; const double *orig=convertObjToPossibleCpp5_Safe(origin,sw,val,a,aa,bb,msg,1,3,true); @@ -2843,7 +2949,7 @@ namespace MEDCoupling return ret.retn(); } - DataArrayInt *getCellIdsCrossingPlane(PyObject *origin, PyObject *vec, double eps) const + DataArrayIdType *getCellIdsCrossingPlane(PyObject *origin, PyObject *vec, double eps) const { int spaceDim=self->getSpaceDimension(); if(spaceDim!=3) @@ -2852,7 +2958,7 @@ namespace MEDCoupling DataArrayDouble *a,*a2; DataArrayDoubleTuple *aa,*aa2; std::vector bb,bb2; - int sw; + mcIdType sw; const char msg[]="Python wrap of MEDCouplingUMesh::getCellIdsCrossingPlane : 1st parameter for origin."; const char msg2[]="Python wrap of MEDCouplingUMesh::getCellIdsCrossingPlane : 2nd parameter for vector."; const double *orig=convertObjToPossibleCpp5_Safe(origin,sw,val,a,aa,bb,msg,1,spaceDim,true); @@ -2862,11 +2968,11 @@ namespace MEDCoupling void convertToPolyTypes(PyObject *li) { - int sw; - int pos1; - std::vector pos2; - DataArrayInt *pos3=0; - DataArrayIntTuple *pos4=0; + mcIdType sw; + mcIdType pos1; + std::vector pos2; + DataArrayIdType *pos3=0; + DataArrayIdTypeTuple *pos4=0; convertIntStarLikePyObjToCpp(li,sw,pos1,pos2,pos3,pos4); switch(sw) { @@ -2912,7 +3018,7 @@ namespace MEDCoupling MEDCouplingUMesh *build3DUnstructuredMesh() const; int get2DCellIdForExtrusion() const; %extend { - MEDCouplingMappedExtrudedMesh(const MEDCouplingUMesh *mesh3D, const MEDCouplingUMesh *mesh2D, int cell2DId) + MEDCouplingMappedExtrudedMesh(const MEDCouplingUMesh *mesh3D, const MEDCouplingUMesh *mesh2D, mcIdType cell2DId) { return MEDCouplingMappedExtrudedMesh::New(mesh3D,mesh2D,cell2DId); } @@ -2955,10 +3061,10 @@ namespace MEDCoupling } PyObject *getMesh3DIds() const { - DataArrayInt *ret=self->getMesh3DIds(); + DataArrayIdType *ret=self->getMesh3DIds(); if(ret) ret->incrRef(); - return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 ); + return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 ); } } }; @@ -2978,15 +3084,15 @@ namespace MEDCoupling { virtual void insertNextCell(PyObject *li) { - int szArr,sw,iTypppArr; - std::vector stdvecTyyppArr; - const int *tmp=convertIntStarLikePyObjToCppIntStar(li,sw,szArr,iTypppArr,stdvecTyyppArr); + mcIdType szArr,sw,iTypppArr; + std::vector stdvecTyyppArr; + const mcIdType *tmp=convertIntStarLikePyObjToCppIntStar(li,sw,szArr,iTypppArr,stdvecTyyppArr); self->insertNextCell(tmp,tmp+szArr); } - virtual DataArrayInt *getNodalConnectivity() const + virtual DataArrayIdType *getNodalConnectivity() const { - DataArrayInt *ret=self->getNodalConnectivity(); + DataArrayIdType *ret=self->getNodalConnectivity(); if(ret) ret->incrRef(); return ret; } @@ -3007,13 +3113,13 @@ namespace MEDCoupling public: static MEDCoupling1SGTUMesh *New(const std::string& name, INTERP_KERNEL::NormalizedCellType type); static MEDCoupling1SGTUMesh *New(const MEDCouplingUMesh *m); - void setNodalConnectivity(DataArrayInt *nodalConn); + void setNodalConnectivity(DataArrayIdType *nodalConn); int getNumberOfNodesPerCell() const; static MEDCoupling1SGTUMesh *Merge1SGTUMeshes(const MEDCoupling1SGTUMesh *mesh1, const MEDCoupling1SGTUMesh *mesh2); MEDCoupling1SGTUMesh *buildSetInstanceFromThis(int spaceDim) const; MEDCoupling1GTUMesh *computeDualMesh() const; MEDCoupling1SGTUMesh *explodeEachHexa8To6Quad4() const; - DataArrayInt *sortHexa8EachOther(); + DataArrayIdType *sortHexa8EachOther(); %extend { MEDCoupling1SGTUMesh() @@ -3045,12 +3151,12 @@ namespace MEDCoupling PyObject *structurizeMe(double eps=1e-12) const { - DataArrayInt *cellPerm(0),*nodePerm(0); + DataArrayIdType *cellPerm(0),*nodePerm(0); MEDCouplingCMesh *retCpp(self->structurizeMe(cellPerm,nodePerm,eps)); PyObject *ret(PyTuple_New(3)); PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(retCpp),SWIGTYPE_p_MEDCoupling__MEDCouplingCMesh, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(cellPerm),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,2,SWIG_NewPointerObj(SWIG_as_voidptr(nodePerm),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(cellPerm),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,2,SWIG_NewPointerObj(SWIG_as_voidptr(nodePerm),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); return ret; } @@ -3079,7 +3185,7 @@ namespace MEDCoupling public: static MEDCoupling1DGTUMesh *New(const std::string& name, INTERP_KERNEL::NormalizedCellType type); static MEDCoupling1DGTUMesh *New(const MEDCouplingUMesh *m); - void setNodalConnectivity(DataArrayInt *nodalConn, DataArrayInt *nodalConnIndex); + void setNodalConnectivity(DataArrayIdType *nodalConn, DataArrayIdType *nodalConnIndex); MEDCoupling1DGTUMesh *buildSetInstanceFromThis(int spaceDim) const; bool isPacked() const; %extend @@ -3110,23 +3216,23 @@ namespace MEDCoupling return oss.str(); } - DataArrayInt *getNodalConnectivityIndex() const + DataArrayIdType *getNodalConnectivityIndex() const { - DataArrayInt *ret=self->getNodalConnectivityIndex(); + DataArrayIdType *ret=self->getNodalConnectivityIndex(); if(ret) ret->incrRef(); return ret; } PyObject *retrievePackedNodalConnectivity() const { - DataArrayInt *ret1=0,*ret2=0; + DataArrayIdType *ret1=0,*ret2=0; bool ret0=self->retrievePackedNodalConnectivity(ret1,ret2); PyObject *ret0Py=ret0?Py_True:Py_False; Py_XINCREF(ret0Py); PyObject *ret=PyTuple_New(3); PyTuple_SetItem(ret,0,ret0Py); - PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,2,SWIG_NewPointerObj(SWIG_as_voidptr(ret2),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,2,SWIG_NewPointerObj(SWIG_as_voidptr(ret2),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); return ret; } @@ -3155,10 +3261,10 @@ namespace MEDCoupling return MEDCoupling1DGTUMesh::Merge1DGTUMeshesOnSameCoords(tmp); } - static DataArrayInt *AggregateNodalConnAndShiftNodeIds(PyObject *li, const std::vector& offsetInNodeIdsPerElt) + static DataArrayIdType *AggregateNodalConnAndShiftNodeIds(PyObject *li, const std::vector& offsetInNodeIdsPerElt) { - std::vector tmp; - convertFromPyObjVectorOfObj(li,SWIGTYPE_p_MEDCoupling__DataArrayInt,"DataArrayInt",tmp); + std::vector tmp; + convertFromPyObjVectorOfObj(li,SWIGTITraits::TI,"DataArrayIdType",tmp); return MEDCoupling1DGTUMesh::AggregateNodalConnAndShiftNodeIds(tmp,offsetInNodeIdsPerElt); } } @@ -3169,32 +3275,32 @@ namespace MEDCoupling class MEDCouplingStructuredMesh : public MEDCoupling::MEDCouplingMesh { public: - int getCellIdFromPos(int i, int j, int k) const; - int getNodeIdFromPos(int i, int j, int k) const; - int getNumberOfCellsOfSubLevelMesh() const; + mcIdType getCellIdFromPos(mcIdType i, mcIdType j, mcIdType k) const; + mcIdType getNodeIdFromPos(mcIdType i, mcIdType j, mcIdType k) const; + mcIdType getNumberOfCellsOfSubLevelMesh() const; int getSpaceDimensionOnNodeStruct() const; double computeSquareness() const; - virtual std::vector getNodeGridStructure() const; - std::vector getCellGridStructure() const; + virtual std::vector getNodeGridStructure() const; + std::vector getCellGridStructure() const; MEDCoupling1SGTUMesh *build1SGTUnstructured() const; - std::vector getLocationFromCellId(int cellId) const; - std::vector getLocationFromNodeId(int cellId) const; + std::vector getLocationFromCellId(mcIdType cellId) const; + std::vector getLocationFromNodeId(mcIdType cellId) const; static INTERP_KERNEL::NormalizedCellType GetGeoTypeGivenMeshDimension(int meshDim); MEDCoupling1SGTUMesh *build1SGTSubLevelMesh() const; - static int DeduceNumberOfGivenStructure(const std::vector& st); - static DataArrayInt *ComputeCornersGhost(const std::vector& st, int ghostLev); - static std::vector GetSplitVectFromStruct(const std::vector& strct); + static mcIdType DeduceNumberOfGivenStructure(const std::vector& st); + static DataArrayIdType *ComputeCornersGhost(const std::vector& st, mcIdType ghostLev); + static std::vector GetSplitVectFromStruct(const std::vector& strct); %extend { virtual MEDCouplingStructuredMesh *buildStructuredSubPart(PyObject *cellPart) const { - int tmpp1=-1,tmpp2=-1; - std::vector tmp=fillArrayWithPyListInt2(cellPart,tmpp1,tmpp2); - std::vector< std::pair > inp; + mcIdType tmpp1=-1,tmpp2=-1; + std::vector tmp=fillArrayWithPyListInt2(cellPart,tmpp1,tmpp2); + std::vector< std::pair > inp; if(tmpp2==2) { inp.resize(tmpp1); - for(int i=0;ibuildStructuredSubPart(inp); } - static DataArrayInt *BuildExplicitIdsFrom(PyObject *st, PyObject *part) + static DataArrayIdType *BuildExplicitIdsFrom(PyObject *st, PyObject *part) { - std::vector< std::pair > inp; + std::vector< std::pair > inp; convertPyToVectorPairInt(part,inp); // - int szArr,sw,iTypppArr; - std::vector stdvecTyyppArr; - const int *tmp4=convertIntStarLikePyObjToCppIntStar(st,sw,szArr,iTypppArr,stdvecTyyppArr); - std::vector tmp5(tmp4,tmp4+szArr); + mcIdType szArr,sw,iTypppArr; + std::vector stdvecTyyppArr; + const mcIdType *tmp4=convertIntStarLikePyObjToCppIntStar(st,sw,szArr,iTypppArr,stdvecTyyppArr); + std::vector tmp5(tmp4,tmp4+szArr); // return MEDCouplingStructuredMesh::BuildExplicitIdsFrom(tmp5,inp); } - static void MultiplyPartOf(const std::vector& st, PyObject *part, double factor, DataArrayDouble *da) + static void MultiplyPartOf(const std::vector& st, PyObject *part, double factor, DataArrayDouble *da) { - std::vector< std::pair > inp; + std::vector< std::pair > inp; convertPyToVectorPairInt(part,inp); MEDCouplingStructuredMesh::MultiplyPartOf(st,inp,factor,da); } - static void MultiplyPartOfByGhost(const std::vector& st, PyObject *part, int ghostSize, double factor, DataArrayDouble *da) + static void MultiplyPartOfByGhost(const std::vector& st, PyObject *part, mcIdType ghostSize, double factor, DataArrayDouble *da) { - std::vector< std::pair > inp; + std::vector< std::pair > inp; convertPyToVectorPairInt(part,inp); MEDCouplingStructuredMesh::MultiplyPartOfByGhost(st,inp,ghostSize,factor,da); } - static PyObject *PutInGhostFormat(int ghostSize, const std::vector& st, PyObject *part) + static PyObject *PutInGhostFormat(mcIdType ghostSize, const std::vector& st, PyObject *part) { - std::vector< std::pair > inp; + std::vector< std::pair > inp; convertPyToVectorPairInt(part,inp); - std::vector stWithGhost; - std::vector< std::pair > partWithGhost; + std::vector stWithGhost; + std::vector< std::pair > partWithGhost; MEDCouplingStructuredMesh::PutInGhostFormat(ghostSize,st,inp,stWithGhost,partWithGhost); PyObject *ret(PyTuple_New(2)); PyTuple_SetItem(ret,0,convertIntArrToPyList2(stWithGhost)); @@ -3250,53 +3356,53 @@ namespace MEDCoupling return ret; } - static DataArrayDouble *ExtractFieldOfDoubleFrom(const std::vector& st, const DataArrayDouble *fieldOfDbl, PyObject *partCompactFormat) + static DataArrayDouble *ExtractFieldOfDoubleFrom(const std::vector& st, const DataArrayDouble *fieldOfDbl, PyObject *partCompactFormat) { - std::vector< std::pair > inp; + std::vector< std::pair > inp; convertPyToVectorPairInt(partCompactFormat,inp); return MEDCouplingStructuredMesh::ExtractFieldOfDoubleFrom(st,fieldOfDbl,inp); } - static void AssignPartOfFieldOfDoubleUsing(const std::vector& st, DataArrayDouble *fieldOfDbl, PyObject *partCompactFormat, const DataArrayDouble *other) + static void AssignPartOfFieldOfDoubleUsing(const std::vector& st, DataArrayDouble *fieldOfDbl, PyObject *partCompactFormat, const DataArrayDouble *other) { - std::vector< std::pair > inp; + std::vector< std::pair > inp; convertPyToVectorPairInt(partCompactFormat,inp); MEDCouplingStructuredMesh::AssignPartOfFieldOfDoubleUsing(st,fieldOfDbl,inp,other); } - static int DeduceNumberOfGivenRangeInCompactFrmt(PyObject *part) + static mcIdType DeduceNumberOfGivenRangeInCompactFrmt(PyObject *part) { - std::vector< std::pair > inp; + std::vector< std::pair > inp; convertPyToVectorPairInt(part,inp); return MEDCouplingStructuredMesh::DeduceNumberOfGivenRangeInCompactFrmt(inp); } - static DataArrayInt *Build1GTNodalConnectivity(PyObject *li) + static DataArrayIdType *Build1GTNodalConnectivity(PyObject *li) { - int szArr,sw,iTypppArr; - std::vector stdvecTyyppArr; - const int *tmp=convertIntStarLikePyObjToCppIntStar(li,sw,szArr,iTypppArr,stdvecTyyppArr); + mcIdType szArr,sw,iTypppArr; + std::vector stdvecTyyppArr; + const mcIdType *tmp=convertIntStarLikePyObjToCppIntStar(li,sw,szArr,iTypppArr,stdvecTyyppArr); return MEDCouplingStructuredMesh::Build1GTNodalConnectivity(tmp,tmp+szArr); } - static DataArrayInt *Build1GTNodalConnectivityOfSubLevelMesh(PyObject *li) + static DataArrayIdType *Build1GTNodalConnectivityOfSubLevelMesh(PyObject *li) { - int szArr,sw,iTypppArr; - std::vector stdvecTyyppArr; - const int *tmp(convertIntStarLikePyObjToCppIntStar(li,sw,szArr,iTypppArr,stdvecTyyppArr)); + mcIdType szArr,sw,iTypppArr; + std::vector stdvecTyyppArr; + const mcIdType *tmp(convertIntStarLikePyObjToCppIntStar(li,sw,szArr,iTypppArr,stdvecTyyppArr)); return MEDCouplingStructuredMesh::Build1GTNodalConnectivityOfSubLevelMesh(tmp,tmp+szArr); } - static std::vector GetDimensionsFromCompactFrmt(PyObject *partCompactFormat) + static std::vector GetDimensionsFromCompactFrmt(PyObject *partCompactFormat) { - std::vector< std::pair > inp; + std::vector< std::pair > inp; convertPyToVectorPairInt(partCompactFormat,inp); return MEDCouplingStructuredMesh::GetDimensionsFromCompactFrmt(inp); } - static PyObject *GetCompactFrmtFromDimensions(const std::vector& dims) + static PyObject *GetCompactFrmtFromDimensions(const std::vector& dims) { - std::vector< std::pair > ret(MEDCouplingStructuredMesh::GetCompactFrmtFromDimensions(dims)); + std::vector< std::pair > ret(MEDCouplingStructuredMesh::GetCompactFrmtFromDimensions(dims)); PyObject *retPy=PyList_New(ret.size()); for(std::size_t i=0;i > r1Cpp,r2Cpp; + std::vector< std::pair > r1Cpp,r2Cpp; convertPyToVectorPairInt(r1,r1Cpp); convertPyToVectorPairInt(r2,r2Cpp); - std::vector< std::pair > ret(MEDCouplingStructuredMesh::IntersectRanges(r1Cpp,r2Cpp)); + std::vector< std::pair > ret(MEDCouplingStructuredMesh::IntersectRanges(r1Cpp,r2Cpp)); PyObject *retPy=PyList_New(ret.size()); for(std::size_t i=0;i > r1Cpp,r2Cpp; + std::vector< std::pair > r1Cpp,r2Cpp; convertPyToVectorPairInt(r1,r1Cpp); convertPyToVectorPairInt(r2,r2Cpp); return MEDCouplingStructuredMesh::AreRangesIntersect(r1Cpp,r2Cpp); @@ -3335,14 +3441,14 @@ namespace MEDCoupling static PyObject *IsPartStructured(PyObject *li, PyObject *st) { - int szArr,sw,iTypppArr; - std::vector stdvecTyyppArr; - const int *tmp=convertIntStarLikePyObjToCppIntStar(li,sw,szArr,iTypppArr,stdvecTyyppArr); - int szArr2,sw2,iTypppArr2; - std::vector stdvecTyyppArr2; - const int *tmp2=convertIntStarLikePyObjToCppIntStar(st,sw2,szArr2,iTypppArr2,stdvecTyyppArr2); - std::vector tmp3(tmp2,tmp2+szArr2); - std::vector< std::pair > partCompactFormat; + mcIdType szArr,sw,iTypppArr; + std::vector stdvecTyyppArr; + const mcIdType *tmp=convertIntStarLikePyObjToCppIntStar(li,sw,szArr,iTypppArr,stdvecTyyppArr); + mcIdType szArr2,sw2,iTypppArr2; + std::vector stdvecTyyppArr2; + const mcIdType *tmp2=convertIntStarLikePyObjToCppIntStar(st,sw2,szArr2,iTypppArr2,stdvecTyyppArr2); + std::vector tmp3(tmp2,tmp2+szArr2); + std::vector< std::pair > partCompactFormat; bool ret0=MEDCouplingStructuredMesh::IsPartStructured(tmp,tmp+szArr,tmp3,partCompactFormat); PyObject *ret=PyTuple_New(2); PyObject *ret0Py=ret0?Py_True:Py_False; Py_XINCREF(ret0Py); @@ -3361,7 +3467,7 @@ namespace MEDCoupling static PyObject *ChangeReferenceFromGlobalOfCompactFrmt(PyObject *bigInAbs, PyObject *partOfBigInAbs, bool check=true) { - std::vector< std::pair > param0,param1,ret; + std::vector< std::pair > param0,param1,ret; convertPyToVectorPairInt(bigInAbs,param0); convertPyToVectorPairInt(partOfBigInAbs,param1); MEDCouplingStructuredMesh::ChangeReferenceFromGlobalOfCompactFrmt(param0,param1,ret,check); @@ -3376,11 +3482,11 @@ namespace MEDCoupling return retPy; } - static PyObject *TranslateCompactFrmt(PyObject *part, const std::vector& translation) + static PyObject *TranslateCompactFrmt(PyObject *part, const std::vector& translation) { - std::vector< std::pair > param0; + std::vector< std::pair > param0; convertPyToVectorPairInt(part,param0); - std::vector< std::pair > ret(MEDCouplingStructuredMesh::TranslateCompactFrmt(param0,translation)); + std::vector< std::pair > ret(MEDCouplingStructuredMesh::TranslateCompactFrmt(param0,translation)); PyObject *retPy(PyList_New(ret.size())); for(std::size_t i=0;i FindTranslationFrom(PyObject *startingFrom, PyObject *goingTo) + static std::vector FindTranslationFrom(PyObject *startingFrom, PyObject *goingTo) { - std::vector< std::pair > param0,param1; + std::vector< std::pair > param0,param1; convertPyToVectorPairInt(startingFrom,param0); convertPyToVectorPairInt(goingTo,param1); return MEDCouplingStructuredMesh::FindTranslationFrom(param0,param1); @@ -3402,7 +3508,7 @@ namespace MEDCoupling static PyObject *ChangeReferenceToGlobalOfCompactFrmt(PyObject *bigInAbs, PyObject *partOfBigRelativeToBig, bool check=true) { - std::vector< std::pair > param0,param1,ret; + std::vector< std::pair > param0,param1,ret; convertPyToVectorPairInt(bigInAbs,param0); convertPyToVectorPairInt(partOfBigRelativeToBig,param1); MEDCouplingStructuredMesh::ChangeReferenceToGlobalOfCompactFrmt(param0,param1,ret,check); @@ -3500,9 +3606,9 @@ namespace MEDCoupling } void setNodeGridStructure(PyObject *gridStruct) { - int szArr,sw,iTypppArr; - std::vector stdvecTyyppArr; - const int *tmp=convertIntStarLikePyObjToCppIntStar(gridStruct,sw,szArr,iTypppArr,stdvecTyyppArr); + mcIdType szArr,sw,iTypppArr; + std::vector stdvecTyyppArr; + const mcIdType *tmp=convertIntStarLikePyObjToCppIntStar(gridStruct,sw,szArr,iTypppArr,stdvecTyyppArr); self->setNodeGridStructure(tmp,tmp+szArr); } } @@ -3518,16 +3624,16 @@ namespace MEDCoupling static MEDCouplingIMesh *New(); // void setSpaceDimension(int spaceDim); - std::vector getNodeStruct() const; + std::vector getNodeStruct() const; std::vector getOrigin() const; std::vector getDXYZ() const; void setAxisUnit(const std::string& unitName); std::string getAxisUnit() const; double getMeasureOfAnyCell() const; MEDCouplingCMesh *convertToCartesian() const; - void refineWithFactor(const std::vector& factors); + void refineWithFactor(const std::vector& factors); MEDCouplingIMesh *asSingleCell() const; - MEDCouplingIMesh *buildWithGhost(int ghostLev) const; + MEDCouplingIMesh *buildWithGhost(mcIdType ghostLev) const; %extend { MEDCouplingIMesh() @@ -3538,15 +3644,15 @@ namespace MEDCoupling { static const char msg0[]="MEDCouplingIMesh::New : error on 'origin' parameter !"; static const char msg1[]="MEDCouplingIMesh::New : error on 'dxyz' parameter !"; - const int *nodeStrctPtr(0); + const mcIdType *nodeStrctPtr(0); const double *originPtr(0),*dxyzPtr(0); - int sw,sz,val0; - std::vector bb0; + mcIdType sw,sz,val0; + std::vector bb0; nodeStrctPtr=convertIntStarLikePyObjToCppIntStar(nodeStrct,sw,sz,val0,bb0); // double val,val2; std::vector bb,bb2; - int sz1,sz2; + mcIdType sz1,sz2; originPtr=convertObjToPossibleCpp5_SingleCompo(origin,sw,val,bb,msg0,false,sz1); dxyzPtr=convertObjToPossibleCpp5_SingleCompo(dxyz,sw,val2,bb2,msg1,false,sz2); // @@ -3560,9 +3666,9 @@ namespace MEDCoupling void setNodeStruct(PyObject *nodeStrct) { - int sw,sz,val0; - std::vector bb0; - const int *nodeStrctPtr(convertIntStarLikePyObjToCppIntStar(nodeStrct,sw,sz,val0,bb0)); + mcIdType sw,sz,val0; + std::vector bb0; + const mcIdType *nodeStrctPtr(convertIntStarLikePyObjToCppIntStar(nodeStrct,sw,sz,val0,bb0)); self->setNodeStruct(nodeStrctPtr,nodeStrctPtr+sz); } @@ -3570,10 +3676,8 @@ namespace MEDCoupling { static const char msg[]="MEDCouplingIMesh::setOrigin : invalid input 'origin' parameter ! integer, float, list/tuple of float, DataArrayDouble or DataArrayDoubleTuple supported !"; double val; - DataArrayDouble *a; - DataArrayDoubleTuple *aa; std::vector bb; - int sw,nbTuples; + mcIdType sw,nbTuples; const double *originPtr(convertObjToPossibleCpp5_SingleCompo(origin,sw,val,bb,msg,false,nbTuples)); self->setOrigin(originPtr,originPtr+nbTuples); } @@ -3582,45 +3686,43 @@ namespace MEDCoupling { static const char msg[]="MEDCouplingIMesh::setDXYZ : invalid input 'dxyz' parameter ! integer, float, list/tuple of float, DataArrayDouble or DataArrayDoubleTuple supported !"; double val; - DataArrayDouble *a; - DataArrayDoubleTuple *aa; std::vector bb; - int sw,nbTuples; + mcIdType sw,nbTuples; const double *originPtr(convertObjToPossibleCpp5_SingleCompo(dxyz,sw,val,bb,msg,false,nbTuples)); self->setDXYZ(originPtr,originPtr+nbTuples); } - static void CondenseFineToCoarse(const std::vector& coarseSt, const DataArrayDouble *fineDA, PyObject *fineLocInCoarse, const std::vector& facts, DataArrayDouble *coarseDA) + static void CondenseFineToCoarse(const std::vector& coarseSt, const DataArrayDouble *fineDA, PyObject *fineLocInCoarse, const std::vector& facts, DataArrayDouble *coarseDA) { - std::vector< std::pair > inp; + std::vector< std::pair > inp; convertPyToVectorPairInt(fineLocInCoarse,inp); MEDCouplingIMesh::CondenseFineToCoarse(coarseSt,fineDA,inp,facts,coarseDA); } - static void CondenseFineToCoarseGhost(const std::vector& coarseSt, const DataArrayDouble *fineDA, PyObject *fineLocInCoarse, const std::vector& facts, DataArrayDouble *coarseDA, int ghostSize) + static void CondenseFineToCoarseGhost(const std::vector& coarseSt, const DataArrayDouble *fineDA, PyObject *fineLocInCoarse, const std::vector& facts, DataArrayDouble *coarseDA, mcIdType ghostSize) { - std::vector< std::pair > inp; + std::vector< std::pair > inp; convertPyToVectorPairInt(fineLocInCoarse,inp); MEDCouplingIMesh::CondenseFineToCoarseGhost(coarseSt,fineDA,inp,facts,coarseDA,ghostSize); } - static void SpreadCoarseToFine(const DataArrayDouble *coarseDA, const std::vector& coarseSt, DataArrayDouble *fineDA, PyObject *fineLocInCoarse, const std::vector& facts) + static void SpreadCoarseToFine(const DataArrayDouble *coarseDA, const std::vector& coarseSt, DataArrayDouble *fineDA, PyObject *fineLocInCoarse, const std::vector& facts) { - std::vector< std::pair > inp; + std::vector< std::pair > inp; convertPyToVectorPairInt(fineLocInCoarse,inp); MEDCouplingIMesh::SpreadCoarseToFine(coarseDA,coarseSt,fineDA,inp,facts); } - static void SpreadCoarseToFineGhost(const DataArrayDouble *coarseDA, const std::vector& coarseSt, DataArrayDouble *fineDA, PyObject *fineLocInCoarse, const std::vector& facts, int ghostSize) + static void SpreadCoarseToFineGhost(const DataArrayDouble *coarseDA, const std::vector& coarseSt, DataArrayDouble *fineDA, PyObject *fineLocInCoarse, const std::vector& facts, mcIdType ghostSize) { - std::vector< std::pair > inp; + std::vector< std::pair > inp; convertPyToVectorPairInt(fineLocInCoarse,inp); MEDCouplingIMesh::SpreadCoarseToFineGhost(coarseDA,coarseSt,fineDA,inp,facts,ghostSize); } - static void SpreadCoarseToFineGhostZone(const DataArrayDouble *coarseDA, const std::vector& coarseSt, DataArrayDouble *fineDA, PyObject *fineLocInCoarse, const std::vector& facts, int ghostSize) + static void SpreadCoarseToFineGhostZone(const DataArrayDouble *coarseDA, const std::vector& coarseSt, DataArrayDouble *fineDA, PyObject *fineLocInCoarse, const std::vector& facts, mcIdType ghostSize) { - std::vector< std::pair > inp; + std::vector< std::pair > inp; convertPyToVectorPairInt(fineLocInCoarse,inp); MEDCouplingIMesh::SpreadCoarseToFineGhostZone(coarseDA,coarseSt,fineDA,inp,facts,ghostSize); } @@ -3649,6 +3751,8 @@ namespace MEDCoupling public: virtual void checkConsistencyLight() const; virtual bool areCompatibleForMerge(const MEDCouplingField *other) const; + bool areStrictlyCompatible(const MEDCouplingField *other) const; + bool areStrictlyCompatibleForMulDiv(const MEDCouplingField *other) const; virtual void copyTinyStringsFrom(const MEDCouplingField *other); void setMesh(const MEDCoupling::MEDCouplingMesh *mesh); void setName(const char *name); @@ -3660,16 +3764,16 @@ namespace MEDCoupling virtual void setNature(NatureOfField nat); DataArrayDouble *getLocalizationOfDiscr() const; MEDCouplingFieldDouble *buildMeasureField(bool isAbs) const; - int getNumberOfTuplesExpected() const; - int getNumberOfMeshPlacesExpected() const; + mcIdType getNumberOfTuplesExpected() const; + mcIdType getNumberOfMeshPlacesExpected() const; void setGaussLocalizationOnType(INTERP_KERNEL::NormalizedCellType type, const std::vector& refCoo, const std::vector& gsCoo, const std::vector& wg); void clearGaussLocalizations(); MEDCouplingGaussLocalization& getGaussLocalization(int locId); - int getNbOfGaussLocalization() const; - int getGaussLocalizationIdOfOneCell(int cellId) const; + mcIdType getNbOfGaussLocalization() const; + mcIdType getGaussLocalizationIdOfOneCell(mcIdType cellId) const; const MEDCouplingGaussLocalization& getGaussLocalization(int locId) const; - int getGaussLocalizationIdOfOneType(INTERP_KERNEL::NormalizedCellType type) const; + mcIdType getGaussLocalizationIdOfOneType(INTERP_KERNEL::NormalizedCellType type) const; void setDiscretization(MEDCouplingFieldDiscretization *newDisc); %extend { PyObject *getMesh() const @@ -3690,45 +3794,45 @@ namespace MEDCoupling PyObject *getGaussLocalizationIdsOfOneType(INTERP_KERNEL::NormalizedCellType type) const { - std::set ret=self->getGaussLocalizationIdsOfOneType(type); + std::set ret=self->getGaussLocalizationIdsOfOneType(type); return convertIntArrToPyList3(ret); } PyObject *buildSubMeshData(PyObject *li) const { - DataArrayInt *ret1=0; + DataArrayIdType *ret1=0; MEDCouplingMesh *ret0=0; void *da=0; - int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_MEDCoupling__DataArrayInt, 0 | 0 ); + int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits::TI, 0 | 0 ); if (!SWIG_IsOK(res1)) { - int size; - INTERP_KERNEL::AutoPtr tmp=convertPyToNewIntArr2(li,&size); + mcIdType size; + INTERP_KERNEL::AutoPtr tmp=convertPyToNewIntArr2(li,&size); ret0=self->buildSubMeshData(tmp,tmp+size,ret1); } else { - DataArrayInt *da2=reinterpret_cast< DataArrayInt * >(da); + DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da); if(!da2) - throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !"); + throw INTERP_KERNEL::Exception("Not null DataArrayIdType instance expected !"); da2->checkAllocated(); ret0=self->buildSubMeshData(da2->getConstPointer(),da2->getConstPointer()+da2->getNbOfElems(),ret1); } PyObject *res = PyList_New(2); PyList_SetItem(res,0,convertMesh(ret0, SWIG_POINTER_OWN | 0 )); - PyList_SetItem(res,1,SWIG_NewPointerObj((void*)ret1,SWIGTYPE_p_MEDCoupling__DataArrayInt,SWIG_POINTER_OWN | 0)); + PyList_SetItem(res,1,SWIG_NewPointerObj((void*)ret1,SWIGTITraits::TI,SWIG_POINTER_OWN | 0)); return res; } - PyObject *buildSubMeshDataRange(int begin, int end, int step) const + PyObject *buildSubMeshDataRange(mcIdType begin, mcIdType end, mcIdType step) const { - DataArrayInt *ret1=0; - int bb,ee,ss; + DataArrayIdType *ret1=0; + mcIdType bb,ee,ss; MEDCouplingMesh *ret0=self->buildSubMeshDataRange(begin,end,step,bb,ee,ss,ret1); PyObject *res=PyTuple_New(2); PyTuple_SetItem(res,0,convertMesh(ret0, SWIG_POINTER_OWN | 0 )); if(ret1) - PyTuple_SetItem(res,1,SWIG_NewPointerObj((void*)ret1,SWIGTYPE_p_MEDCoupling__DataArrayInt,SWIG_POINTER_OWN | 0)); + PyTuple_SetItem(res,1,SWIG_NewPointerObj((void*)ret1,SWIGTITraits::TI,SWIG_POINTER_OWN | 0)); else { PyObject *res1=PySlice_New(PyInt_FromLong(bb),PyInt_FromLong(ee),PyInt_FromLong(ss)); @@ -3737,11 +3841,11 @@ namespace MEDCoupling return res; } - DataArrayInt *computeTupleIdsToSelectFromCellIds(PyObject *cellIds) const + DataArrayIdType *computeTupleIdsToSelectFromCellIds(PyObject *cellIds) const { - int sw,sz(-1); - int v0; std::vector v1; - const int *cellIdsBg(convertIntStarLikePyObjToCppIntStar(cellIds,sw,sz,v0,v1)); + mcIdType sw,sz(-1); + mcIdType v0; std::vector v1; + const mcIdType *cellIdsBg(convertIntStarLikePyObjToCppIntStar(cellIds,sw,sz,v0,v1)); return self->computeTupleIdsToSelectFromCellIds(cellIdsBg,cellIdsBg+sz); } @@ -3749,18 +3853,18 @@ namespace MEDCoupling const std::vector& gsCoo, const std::vector& wg) { void *da=0; - int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_MEDCoupling__DataArrayInt, 0 | 0 ); + int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits::TI, 0 | 0 ); if (!SWIG_IsOK(res1)) { - int size; - INTERP_KERNEL::AutoPtr tmp=convertPyToNewIntArr2(li,&size); - self->setGaussLocalizationOnCells(tmp,((int *)tmp)+size,refCoo,gsCoo,wg); + mcIdType size; + INTERP_KERNEL::AutoPtr tmp=convertPyToNewIntArr2(li,&size); + self->setGaussLocalizationOnCells(tmp,((mcIdType *)tmp)+size,refCoo,gsCoo,wg); } else { - DataArrayInt *da2=reinterpret_cast< DataArrayInt * >(da); + DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da); if(!da2) - throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !"); + throw INTERP_KERNEL::Exception("Not null DataArrayIdType instance expected !"); da2->checkAllocated(); self->setGaussLocalizationOnCells(da2->getConstPointer(),da2->getConstPointer()+da2->getNbOfElems(),refCoo,gsCoo,wg); } @@ -3768,20 +3872,20 @@ namespace MEDCoupling PyObject *getCellIdsHavingGaussLocalization(int locId) const { - std::vector tmp; + std::vector tmp; self->getCellIdsHavingGaussLocalization(locId,tmp); - DataArrayInt *ret=DataArrayInt::New(); - ret->alloc((int)tmp.size(),1); + DataArrayIdType *ret=DataArrayIdType::New(); + ret->alloc((mcIdType)tmp.size(),1); std::copy(tmp.begin(),tmp.end(),ret->getPointer()); - return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 ); + return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 ); } - int getNumberOfTuplesExpectedRegardingCode(PyObject *code, PyObject *idsPerType) const + mcIdType getNumberOfTuplesExpectedRegardingCode(PyObject *code, PyObject *idsPerType) const { - std::vector inp0; + std::vector inp0; convertPyToNewIntArr4(code,1,3,inp0); - std::vector inp1; - convertFromPyObjVectorOfObj(idsPerType,SWIGTYPE_p_MEDCoupling__DataArrayInt,"DataArrayInt",inp1); + std::vector inp1; + convertFromPyObjVectorOfObj(idsPerType,SWIGTITraits::TI,"DataArrayIdType",inp1); return self->getNumberOfTuplesExpectedRegardingCode(inp0,inp1); } } @@ -3792,7 +3896,8 @@ namespace MEDCoupling public: static MEDCouplingFieldTemplate *New(const MEDCouplingFieldDouble& f); static MEDCouplingFieldTemplate *New(const MEDCouplingFieldFloat& f); - static MEDCouplingFieldTemplate *New(const MEDCouplingFieldInt& f); + static MEDCouplingFieldTemplate *New(const MEDCouplingFieldInt32& f); + static MEDCouplingFieldTemplate *New(const MEDCouplingFieldInt64& f); static MEDCouplingFieldTemplate *New(TypeOfField type); std::string simpleRepr() const; std::string advancedRepr() const; @@ -3810,7 +3915,12 @@ namespace MEDCoupling return MEDCouplingFieldTemplate::New(f); } - MEDCouplingFieldTemplate(const MEDCouplingFieldInt& f) + MEDCouplingFieldTemplate(const MEDCouplingFieldInt32& f) + { + return MEDCouplingFieldTemplate::New(f); + } + + MEDCouplingFieldTemplate(const MEDCouplingFieldInt64& f) { return MEDCouplingFieldTemplate::New(f); } @@ -3860,7 +3970,8 @@ namespace MEDCoupling %template(MEDCouplingFieldTfloat) MEDCoupling::MEDCouplingFieldT; %template(MEDCouplingFieldTint) MEDCoupling::MEDCouplingFieldT; - class MEDCouplingFieldInt; + class MEDCouplingFieldInt32; + class MEDCouplingFieldInt64; class MEDCouplingFieldFloat; class MEDCouplingFieldDouble : public MEDCouplingFieldT @@ -3878,7 +3989,7 @@ namespace MEDCoupling std::string simpleRepr() const; std::string advancedRepr() const; std::string writeVTK(const std::string& fileName, bool isBinary=true) const; - MEDCouplingFieldInt *convertToIntField() const; + MEDCouplingFieldInt32 *convertToIntField() const; MEDCouplingFieldFloat *convertToFloatField() const; MEDCouplingFieldDouble *clone(bool recDeepCpy) const; MEDCouplingFieldDouble *cloneWithMesh(bool recDeepCpy) const; @@ -3923,7 +4034,7 @@ namespace MEDCoupling MEDCouplingFieldDouble *deviator() const; MEDCouplingFieldDouble *magnitude() const; MEDCouplingFieldDouble *maxPerTuple() const; - void changeNbOfComponents(int newNbOfComp, double dftValue=0.); + void changeNbOfComponents(std::size_t newNbOfComp, double dftValue=0.); void sortPerTuple(bool asc); MEDCouplingFieldDouble &operator=(double value); void fillFromAnalytic(int nbOfComp, const std::string& func); @@ -3947,7 +4058,7 @@ namespace MEDCoupling double normL1(int compId) const; double normL2(int compId) const; double normMax(int compId) const; - DataArrayInt *findIdsInRange(double vmin, double vmax) const; + DataArrayIdType *findIdsInRange(double vmin, double vmax) const; MEDCouplingFieldDouble *buildSubPartRange(int begin, int end, int step) const; static MEDCouplingFieldDouble *MergeFields(const MEDCouplingFieldDouble *f1, const MEDCouplingFieldDouble *f2); static MEDCouplingFieldDouble *MeldFields(const MEDCouplingFieldDouble *f1, const MEDCouplingFieldDouble *f2); @@ -4018,7 +4129,7 @@ namespace MEDCoupling DataArrayDouble *a,*a2; DataArrayDoubleTuple *aa,*aa2; std::vector bb,bb2; - int sw; + mcIdType sw; const double *centerPtr=convertObjToPossibleCpp5_Safe(center,sw,val,a,aa,bb,msg,1,3,true); const double *vectorPtr=convertObjToPossibleCpp5_Safe(vector,sw,val2,a2,aa2,bb2,msg,1,3,true); return self->computeVectorFieldCyl(centerPtr,vectorPtr); @@ -4038,9 +4149,9 @@ namespace MEDCoupling for(std::vector::iterator it=arrs.begin();it!=arrs.end();it++) if(*it) (*it)->incrRef(); - int sz=arrs.size(); + std::size_t sz=arrs.size(); PyObject *ret=PyTuple_New(sz); - for(int i=0;i tmp; convertFromPyObjVectorOfObj(ls,SWIGTYPE_p_MEDCoupling__DataArrayDouble,"DataArrayDouble",tmp); - int sz=tmp.size(); + std::size_t sz=tmp.size(); std::vector arrs(sz); - for(int i=0;i(tmp[i]); self->setArrays(arrs); } @@ -4075,7 +4186,7 @@ namespace MEDCoupling DataArrayDouble *a; DataArrayDoubleTuple *aa; std::vector bb; - int sw; + mcIdType sw; const MEDCouplingMesh *mesh=self->getMesh(); if(!mesh) throw INTERP_KERNEL::Exception("Python wrap of MEDCouplingFieldDouble::getValueOn : no underlying mesh !"); @@ -4083,15 +4194,15 @@ namespace MEDCoupling const char msg[]="Python wrap of MEDCouplingFieldDouble::getValueOn : "; const double *spaceLoc=convertObjToPossibleCpp5_Safe(sl,sw,val,a,aa,bb,msg,1,spaceDim,true); // - int sz=self->getNumberOfComponents(); + mcIdType sz=ToIdType(self->getNumberOfComponents()); INTERP_KERNEL::AutoPtr res=new double[sz]; self->getValueOn(spaceLoc,res); return convertDblArrToPyList(res,sz); } - PyObject *getValueOnPos(int i, int j, int k) const + PyObject *getValueOnPos(mcIdType i, mcIdType j, mcIdType k) const { - int sz=self->getNumberOfComponents(); + mcIdType sz=ToIdType(self->getNumberOfComponents()); INTERP_KERNEL::AutoPtr res=new double[sz]; self->getValueOnPos(i,j,k,res); return convertDblArrToPyList(res,sz); @@ -4103,11 +4214,11 @@ namespace MEDCoupling if(!mesh) throw INTERP_KERNEL::Exception("Python wrap MEDCouplingFieldDouble::getValueOnMulti : lying on a null mesh !"); // - int sw,nbPts; + mcIdType sw,nbPts; double v0; MEDCoupling::DataArrayDouble *v1(0); MEDCoupling::DataArrayDoubleTuple *v2(0); std::vector v3; const double *inp=convertObjToPossibleCpp5_Safe2(locs,sw,v0,v1,v2,v3,"wrap of MEDCouplingFieldDouble::getValueOnMulti", mesh->getSpaceDimension(),true,nbPts); - return self->getValueOnMulti(inp,nbPts); + return self->getValueOnMulti(inp,(int)nbPts); } PyObject *getValueOn(PyObject *sl, double time) const @@ -4116,7 +4227,7 @@ namespace MEDCoupling DataArrayDouble *a; DataArrayDoubleTuple *aa; std::vector bb; - int sw; + mcIdType sw; const MEDCouplingMesh *mesh=self->getMesh(); if(!mesh) throw INTERP_KERNEL::Exception("Python wrap of MEDCouplingFieldDouble::getValueOn : no underlying mesh !"); @@ -4125,7 +4236,7 @@ namespace MEDCoupling const double *spaceLoc=convertObjToPossibleCpp5_Safe(sl,sw,val,a,aa,bb,msg,1,spaceDim,true); // // - int sz=self->getNumberOfComponents(); + mcIdType sz=ToIdType(self->getNumberOfComponents()); INTERP_KERNEL::AutoPtr res=new double[sz]; self->getValueOn(spaceLoc,time,res); return convertDblArrToPyList(res,sz); @@ -4177,75 +4288,75 @@ namespace MEDCoupling } PyObject *accumulate() const { - int sz=self->getNumberOfComponents(); + mcIdType sz=ToIdType(self->getNumberOfComponents()); INTERP_KERNEL::AutoPtr tmp=new double[sz]; self->accumulate(tmp); return convertDblArrToPyList(tmp,sz); } PyObject *integral(bool isWAbs) const { - int sz=self->getNumberOfComponents(); + mcIdType sz=ToIdType(self->getNumberOfComponents()); INTERP_KERNEL::AutoPtr tmp=new double[sz]; self->integral(isWAbs,tmp); return convertDblArrToPyList(tmp,sz); } PyObject *getWeightedAverageValue(bool isWAbs=true) const { - int sz=self->getNumberOfComponents(); + mcIdType sz=ToIdType(self->getNumberOfComponents()); INTERP_KERNEL::AutoPtr tmp=new double[sz]; self->getWeightedAverageValue(tmp,isWAbs); return convertDblArrToPyList(tmp,sz); } PyObject *normL1() const { - int sz=self->getNumberOfComponents(); + mcIdType sz=ToIdType(self->getNumberOfComponents()); INTERP_KERNEL::AutoPtr tmp=new double[sz]; self->normL1(tmp); return convertDblArrToPyList(tmp,sz); } PyObject *normL2() const { - int sz=self->getNumberOfComponents(); + mcIdType sz=ToIdType(self->getNumberOfComponents()); INTERP_KERNEL::AutoPtr tmp=new double[sz]; self->normL2(tmp); return convertDblArrToPyList(tmp,sz); } PyObject *normMax() const { - int sz=self->getNumberOfComponents(); + mcIdType sz=ToIdType(self->getNumberOfComponents()); INTERP_KERNEL::AutoPtr tmp=new double[sz]; self->normMax(tmp); return convertDblArrToPyList(tmp,sz); } void renumberCells(PyObject *li, bool check=true) { - int szArr,sw,iTypppArr; - std::vector stdvecTyyppArr; - const int *tmp=convertIntStarLikePyObjToCppIntStar(li,sw,szArr,iTypppArr,stdvecTyyppArr); + mcIdType szArr,sw,iTypppArr; + std::vector stdvecTyyppArr; + const mcIdType *tmp=convertIntStarLikePyObjToCppIntStar(li,sw,szArr,iTypppArr,stdvecTyyppArr); self->renumberCells(tmp,check); } void renumberCellsWithoutMesh(PyObject *li, bool check=true) { - int szArr,sw,iTypppArr; - std::vector stdvecTyyppArr; - const int *tmp=convertIntStarLikePyObjToCppIntStar(li,sw,szArr,iTypppArr,stdvecTyyppArr); + mcIdType szArr,sw,iTypppArr; + std::vector stdvecTyyppArr; + const mcIdType *tmp=convertIntStarLikePyObjToCppIntStar(li,sw,szArr,iTypppArr,stdvecTyyppArr); self->renumberCellsWithoutMesh(tmp,check); } void renumberNodes(PyObject *li, double eps=1e-15) { - int szArr,sw,iTypppArr; - std::vector stdvecTyyppArr; - const int *tmp=convertIntStarLikePyObjToCppIntStar(li,sw,szArr,iTypppArr,stdvecTyyppArr); + mcIdType szArr,sw,iTypppArr; + std::vector stdvecTyyppArr; + const mcIdType *tmp=convertIntStarLikePyObjToCppIntStar(li,sw,szArr,iTypppArr,stdvecTyyppArr); self->renumberNodes(tmp,eps); } - void renumberNodesWithoutMesh(PyObject *li, int newNbOfNodes, double eps=1e-15) + void renumberNodesWithoutMesh(PyObject *li, mcIdType newNbOfNodes, double eps=1e-15) { - int szArr,sw,iTypppArr; - std::vector stdvecTyyppArr; - const int *tmp=convertIntStarLikePyObjToCppIntStar(li,sw,szArr,iTypppArr,stdvecTyyppArr); + mcIdType szArr,sw,iTypppArr; + std::vector stdvecTyyppArr; + const mcIdType *tmp=convertIntStarLikePyObjToCppIntStar(li,sw,szArr,iTypppArr,stdvecTyyppArr); self->renumberNodesWithoutMesh(tmp,newNbOfNodes,eps); } @@ -4261,34 +4372,34 @@ namespace MEDCoupling PyObject *getMaxValue2() const { - DataArrayInt *tmp; + DataArrayIdType *tmp; double r1=self->getMaxValue2(tmp); PyObject *ret=PyTuple_New(2); PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1)); - PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(tmp),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(tmp),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); return ret; } PyObject *getMinValue2() const { - DataArrayInt *tmp; + DataArrayIdType *tmp; double r1=self->getMinValue2(tmp); PyObject *ret=PyTuple_New(2); PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1)); - PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(tmp),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); + PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(tmp),SWIGTITraits::TI, SWIG_POINTER_OWN | 0 )); return ret; } MEDCouplingFieldDouble *keepSelectedComponents(PyObject *li) const { - std::vector tmp; + std::vector tmp; convertPyToNewIntArr3(li,tmp); return self->keepSelectedComponents(tmp); } void setSelectedComponents(const MEDCouplingFieldDouble *f, PyObject *li) { - std::vector tmp; + std::vector tmp; convertPyToNewIntArr3(li,tmp); self->setSelectedComponents(f,tmp); } @@ -4299,7 +4410,7 @@ namespace MEDCoupling DataArrayDouble *a,*a2; DataArrayDoubleTuple *aa,*aa2; std::vector bb,bb2; - int sw; + mcIdType sw; int spaceDim=3; const char msg[]="Python wrap of MEDCouplingFieldDouble::extractSlice3D : 1st parameter for origin."; const char msg2[]="Python wrap of MEDCouplingFieldDouble::extractSlice3D : 2nd parameter for vector."; @@ -4338,7 +4449,7 @@ namespace MEDCoupling DataArrayDouble *a; DataArrayDoubleTuple *aa; std::vector bb; - int sw; + mcIdType sw; convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb); switch(sw) { @@ -4375,7 +4486,7 @@ namespace MEDCoupling { if(!self->getArray()) throw INTERP_KERNEL::Exception(msg2); - MCAuto aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,(int)bb.size()); + MCAuto aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size()); MCAuto ret=DataArrayDouble::Substract(self->getArray(),aaa); MCAuto ret2=self->clone(false); ret2->setArray(ret); @@ -4420,7 +4531,7 @@ namespace MEDCoupling DataArrayDouble *a; DataArrayDoubleTuple *aa; std::vector bb; - int sw; + mcIdType sw; convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb); switch(sw) { @@ -4459,7 +4570,7 @@ namespace MEDCoupling { if(!self->getArray()) throw INTERP_KERNEL::Exception(msg2); - MCAuto aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,(int)bb.size()); + MCAuto aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size()); MCAuto ret=DataArrayDouble::Divide(self->getArray(),aaa); MCAuto ret2=self->clone(false); ret2->setArray(ret); @@ -4494,7 +4605,7 @@ namespace MEDCoupling DataArrayDouble *a; DataArrayDoubleTuple *aa; std::vector bb; - int sw; + mcIdType sw; convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb); switch(sw) { @@ -4531,7 +4642,7 @@ namespace MEDCoupling { if(!self->getArray()) throw INTERP_KERNEL::Exception(msg2); - MCAuto aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,(int)bb.size()); + MCAuto aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size()); MCAuto ret=DataArrayDouble::Pow(self->getArray(),aaa); MCAuto ret2=self->clone(false); ret2->setArray(ret); @@ -4570,7 +4681,7 @@ namespace MEDCoupling DataArrayDouble *a; DataArrayDoubleTuple *aa; std::vector bb; - int sw; + mcIdType sw; convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb); switch(sw) { @@ -4603,7 +4714,7 @@ namespace MEDCoupling { if(!self->getArray()) throw INTERP_KERNEL::Exception(msg2); - MCAuto aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,(int)bb.size()); + MCAuto aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size()); self->getArray()->addEqual(aaa); Py_XINCREF(trueSelf); return trueSelf; @@ -4636,7 +4747,7 @@ namespace MEDCoupling DataArrayDouble *a; DataArrayDoubleTuple *aa; std::vector bb; - int sw; + mcIdType sw; convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb); switch(sw) { @@ -4669,7 +4780,7 @@ namespace MEDCoupling { if(!self->getArray()) throw INTERP_KERNEL::Exception(msg2); - MCAuto aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,(int)bb.size()); + MCAuto aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size()); self->getArray()->substractEqual(aaa); Py_XINCREF(trueSelf); return trueSelf; @@ -4702,7 +4813,7 @@ namespace MEDCoupling DataArrayDouble *a; DataArrayDoubleTuple *aa; std::vector bb; - int sw; + mcIdType sw; convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb); switch(sw) { @@ -4768,7 +4879,7 @@ namespace MEDCoupling DataArrayDouble *a; DataArrayDoubleTuple *aa; std::vector bb; - int sw; + mcIdType sw; convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb); switch(sw) { @@ -4803,7 +4914,7 @@ namespace MEDCoupling { if(!self->getArray()) throw INTERP_KERNEL::Exception(msg2); - MCAuto aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,(int)bb.size()); + MCAuto aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size()); self->getArray()->divideEqual(aaa); Py_XINCREF(trueSelf); return trueSelf; @@ -4836,7 +4947,7 @@ namespace MEDCoupling DataArrayDouble *a; DataArrayDoubleTuple *aa; std::vector bb; - int sw; + mcIdType sw; convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb); switch(sw) { @@ -4869,7 +4980,7 @@ namespace MEDCoupling { if(!self->getArray()) throw INTERP_KERNEL::Exception(msg2); - MCAuto aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,(int)bb.size()); + MCAuto aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size()); self->getArray()->powEqual(aaa); Py_XINCREF(trueSelf); return trueSelf; @@ -4935,9 +5046,9 @@ namespace MEDCoupling { std::vector tmp; convertFromPyObjVectorOfObj(li,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,"MEDCouplingFieldDouble",tmp); - int sz=tmp.size(); + std::size_t sz=tmp.size(); std::vector fs(sz); - for(int i=0;i(tmp[i]); return MEDCouplingMultiFields::New(fs); } @@ -4945,18 +5056,18 @@ namespace MEDCoupling { std::vector tmp; convertFromPyObjVectorOfObj(li,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,"MEDCouplingFieldDouble",tmp); - int sz=tmp.size(); + std::size_t sz=tmp.size(); std::vector fs(sz); - for(int i=0;i(tmp[i]); return MEDCouplingMultiFields::New(fs); } PyObject *getFields() const { std::vector fields=self->getFields(); - int sz=fields.size(); + std::size_t sz=fields.size(); PyObject *res = PyList_New(sz); - for(int i=0;i ms=self->getMeshes(); - int sz=ms.size(); + std::size_t sz=ms.size(); PyObject *res = PyList_New(sz); - for(int i=0;i refs; std::vector ms=self->getDifferentMeshes(refs); - int sz=ms.size(); + std::size_t sz=ms.size(); PyObject *res = PyList_New(sz); - for(int i=0;i ms=self->getArrays(); - int sz=ms.size(); + std::size_t sz=ms.size(); PyObject *res = PyList_New(sz); - for(int i=0;i > refs; std::vector ms=self->getDifferentArrays(refs); - int sz=ms.size(); + std::size_t sz=ms.size(); PyObject *res = PyList_New(sz); PyObject *res2 = PyList_New(sz); - for(int i=0;i + class MEDCouplingFieldInt32 : public MEDCouplingFieldT { public: - static MEDCouplingFieldInt *New(TypeOfField type, TypeOfTimeDiscretization td=ONE_TIME); - static MEDCouplingFieldInt *New(const MEDCouplingFieldTemplate& ft, TypeOfTimeDiscretization td=ONE_TIME); - bool isEqual(const MEDCouplingFieldInt *other, double meshPrec, int valsPrec) const; - bool isEqualWithoutConsideringStr(const MEDCouplingFieldInt *other, double meshPrec, int valsPrec) const; + static MEDCouplingFieldInt32 *New(TypeOfField type, TypeOfTimeDiscretization td=ONE_TIME); + static MEDCouplingFieldInt32 *New(const MEDCouplingFieldTemplate& ft, TypeOfTimeDiscretization td=ONE_TIME); + bool isEqual(const MEDCouplingFieldInt32 *other, double meshPrec, int valsPrec) const; + bool isEqualWithoutConsideringStr(const MEDCouplingFieldInt32 *other, double meshPrec, int valsPrec) const; void setTimeUnit(const std::string& unit); std::string getTimeUnit() const; void setTime(double val, int iteration, int order); - void setArray(DataArrayInt *array); - MEDCouplingFieldInt *deepCopy() const; - MEDCouplingFieldInt *clone(bool recDeepCpy) const; - MEDCouplingFieldInt *cloneWithMesh(bool recDeepCpy) const; + void setArray(DataArrayInt32 *array); + MEDCouplingFieldInt32 *deepCopy() const; + MEDCouplingFieldInt32 *clone(bool recDeepCpy) const; + MEDCouplingFieldInt32 *cloneWithMesh(bool recDeepCpy) const; MEDCouplingFieldDouble *convertToDblField() const; - MEDCouplingFieldInt *buildSubPartRange(int begin, int end, int step) const; + MEDCouplingFieldInt32 *buildSubPartRange(int begin, int end, int step) const; %extend { - MEDCouplingFieldInt(TypeOfField type, TypeOfTimeDiscretization td=ONE_TIME) + MEDCouplingFieldInt32(TypeOfField type, TypeOfTimeDiscretization td=ONE_TIME) { - return MEDCouplingFieldInt::New(type,td); + return MEDCouplingFieldInt32::New(type,td); } - MEDCouplingFieldInt(const MEDCouplingFieldTemplate& ft, TypeOfTimeDiscretization td=ONE_TIME) + MEDCouplingFieldInt32(const MEDCouplingFieldTemplate& ft, TypeOfTimeDiscretization td=ONE_TIME) { - return MEDCouplingFieldInt::New(ft,td); + return MEDCouplingFieldInt32::New(ft,td); } - PyObject *isEqualIfNotWhy(const MEDCouplingFieldInt *other, double meshPrec, int valsPrec) const + PyObject *isEqualIfNotWhy(const MEDCouplingFieldInt32 *other, double meshPrec, int valsPrec) const { std::string ret1; bool ret0=self->isEqualIfNotWhy(other,meshPrec,valsPrec,ret1); @@ -5123,19 +5234,19 @@ namespace MEDCoupling return oss.str(); } - MEDCouplingFieldInt *buildSubPart(PyObject *li) const + MEDCouplingFieldInt32 *buildSubPart(PyObject *li) const { return fieldT_buildSubPart(self,li); } - MEDCouplingFieldInt *__getitem__(PyObject *li) const + MEDCouplingFieldInt32 *__getitem__(PyObject *li) const { return fieldT__getitem__(self,li); } - DataArrayInt *getArray() + DataArrayInt32 *getArray() { - DataArrayInt *ret=self->getArray(); + DataArrayInt32 *ret=self->getArray(); if(ret) ret->incrRef(); return ret; @@ -5154,7 +5265,7 @@ namespace MEDCoupling PyObject *getTinySerializationInformation() const { - return field_getTinySerializationInformation(self); + return field_getTinySerializationInformation(self); } PyObject *serialize() const @@ -5164,7 +5275,7 @@ namespace MEDCoupling PyObject *__getstate__() const { - return field__getstate__(self,MEDCoupling_MEDCouplingFieldInt_getTinySerializationInformation,MEDCoupling_MEDCouplingFieldInt_serialize); + return field__getstate__(self,MEDCoupling_MEDCouplingFieldInt32_getTinySerializationInformation,MEDCoupling_MEDCouplingFieldInt32_serialize); } void __setstate__(PyObject *inp) @@ -5174,6 +5285,108 @@ namespace MEDCoupling } }; + class MEDCouplingFieldInt64 : public MEDCouplingFieldT + { + public: + static MEDCouplingFieldInt64 *New(TypeOfField type, TypeOfTimeDiscretization td=ONE_TIME); + static MEDCouplingFieldInt64 *New(const MEDCouplingFieldTemplate& ft, TypeOfTimeDiscretization td=ONE_TIME); + bool isEqual(const MEDCouplingFieldInt64 *other, double meshPrec, int valsPrec) const; + bool isEqualWithoutConsideringStr(const MEDCouplingFieldInt64 *other, double meshPrec, int valsPrec) const; + void setTimeUnit(const std::string& unit); + std::string getTimeUnit() const; + void setTime(double val, int iteration, int order); + void setArray(DataArrayInt64 *array); + MEDCouplingFieldInt64 *deepCopy() const; + MEDCouplingFieldInt64 *clone(bool recDeepCpy) const; + MEDCouplingFieldInt64 *cloneWithMesh(bool recDeepCpy) const; + MEDCouplingFieldDouble *convertToDblField() const; + MEDCouplingFieldInt64 *buildSubPartRange(int begin, int end, int step) const; + %extend { + MEDCouplingFieldInt64(TypeOfField type, TypeOfTimeDiscretization td=ONE_TIME) + { + return MEDCouplingFieldInt64::New(type,td); + } + + MEDCouplingFieldInt64(const MEDCouplingFieldTemplate& ft, TypeOfTimeDiscretization td=ONE_TIME) + { + return MEDCouplingFieldInt64::New(ft,td); + } + + PyObject *isEqualIfNotWhy(const MEDCouplingFieldInt64 *other, double meshPrec, int valsPrec) const + { + std::string ret1; + bool ret0=self->isEqualIfNotWhy(other,meshPrec,valsPrec,ret1); + PyObject *ret=PyTuple_New(2); + PyObject *ret0Py=ret0?Py_True:Py_False; + Py_XINCREF(ret0Py); + PyTuple_SetItem(ret,0,ret0Py); + PyTuple_SetItem(ret,1,PyString_FromString(ret1.c_str())); + return ret; + } + + std::string __str__() const + { + return self->simpleRepr(); + } + + std::string __repr__() const + { + std::ostringstream oss; + self->reprQuickOverview(oss); + return oss.str(); + } + + MEDCouplingFieldInt64 *buildSubPart(PyObject *li) const + { + return fieldT_buildSubPart(self,li); + } + + MEDCouplingFieldInt64 *__getitem__(PyObject *li) const + { + return fieldT__getitem__(self,li); + } + + DataArrayInt64 *getArray() + { + DataArrayInt64 *ret=self->getArray(); + if(ret) + ret->incrRef(); + return ret; + } + + PyObject *getTime() + { + int tmp1,tmp2; + double tmp0=self->getTime(tmp1,tmp2); + PyObject *res = PyList_New(3); + PyList_SetItem(res,0,SWIG_From_double(tmp0)); + PyList_SetItem(res,1,SWIG_From_int(tmp1)); + PyList_SetItem(res,2,SWIG_From_int(tmp2)); + return res; + } + + PyObject *getTinySerializationInformation() const + { + return field_getTinySerializationInformation(self); + } + + PyObject *serialize() const + { + return field_serialize(self); + } + + PyObject *__getstate__() const + { + return field__getstate__(self,MEDCoupling_MEDCouplingFieldInt64_getTinySerializationInformation,MEDCoupling_MEDCouplingFieldInt64_serialize); + } + + void __setstate__(PyObject *inp) + { + field__setstate__(self,inp); + } + } + }; + class MEDCouplingFieldFloat : public MEDCouplingFieldT { public: @@ -5331,9 +5544,9 @@ namespace MEDCoupling { std::vector tmp; convertFromPyObjVectorOfObj(li,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,"MEDCouplingFieldDouble",tmp); - int sz=tmp.size(); + std::size_t sz=tmp.size(); std::vector fs(sz); - for(int i=0;i(tmp[i]); return MEDCouplingFieldOverTime::New(fs); } @@ -5342,15 +5555,15 @@ namespace MEDCoupling return self->simpleRepr(); } static MEDCouplingFieldOverTime *New(PyObject *li) - { - std::vector tmp; - convertFromPyObjVectorOfObj(li,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,"MEDCouplingFieldDouble",tmp); - int sz=tmp.size(); - std::vector fs(sz); - for(int i=0;i(tmp[i]); - return MEDCouplingFieldOverTime::New(fs); - } + { + std::vector tmp; + convertFromPyObjVectorOfObj(li,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,"MEDCouplingFieldDouble",tmp); + std::size_t sz=tmp.size(); + std::vector fs(sz); + for(std::size_t i=0;i(tmp[i]); + return MEDCouplingFieldOverTime::New(fs); + } } }; @@ -5379,29 +5592,29 @@ namespace MEDCoupling public: int getNumberOfOverlapedCellsForFather() const; bool isInMyNeighborhood(const MEDCouplingCartesianAMRPatch *other, int ghostLev) const; - std::vector computeCellGridSt() const; + std::vector computeCellGridSt() const; %extend { PyObject *getBLTRRange() const { - const std::vector< std::pair >& ret(self->getBLTRRange()); + const std::vector< std::pair >& ret(self->getBLTRRange()); return convertFromVectorPairInt(ret); } PyObject *getBLTRRangeRelativeToGF() const { - std::vector< std::pair > ret(self->getBLTRRangeRelativeToGF()); + std::vector< std::pair > ret(self->getBLTRRangeRelativeToGF()); return convertFromVectorPairInt(ret); } - void addPatch(PyObject *bottomLeftTopRight, const std::vector& factors) + void addPatch(PyObject *bottomLeftTopRight, const std::vector& factors) { - std::vector< std::pair > inp; + std::vector< std::pair > inp; convertPyToVectorPairInt(bottomLeftTopRight,inp); self->addPatch(inp,factors); } - MEDCouplingCartesianAMRPatch *__getitem__(int patchId) const + MEDCouplingCartesianAMRPatch *__getitem__(mcIdType patchId) const { const MEDCouplingCartesianAMRMeshGen *mesh(self->getMesh()); if(!mesh) @@ -5419,7 +5632,7 @@ namespace MEDCoupling return ret; } - void __delitem__(int patchId) + void __delitem__(mcIdType patchId) { MEDCouplingCartesianAMRMeshGen *mesh(const_cast(self->getMesh())); if(!mesh) @@ -5427,7 +5640,7 @@ namespace MEDCoupling mesh->removePatch(patchId); } - int __len__() const + mcIdType __len__() const { const MEDCouplingCartesianAMRMeshGen *mesh(self->getMesh()); if(!mesh) @@ -5444,45 +5657,45 @@ namespace MEDCoupling class MEDCouplingCartesianAMRMeshGen : public RefCountObject, public TimeLabel { public: - int getAbsoluteLevel() const; - int getAbsoluteLevelRelativeTo(const MEDCouplingCartesianAMRMeshGen *ref) const; - std::vector getPositionRelativeTo(const MEDCouplingCartesianAMRMeshGen *ref) const; + mcIdType getAbsoluteLevel() const; + mcIdType getAbsoluteLevelRelativeTo(const MEDCouplingCartesianAMRMeshGen *ref) const; + std::vector getPositionRelativeTo(const MEDCouplingCartesianAMRMeshGen *ref) const; int getSpaceDimension() const; - const std::vector& getFactors() const; - void setFactors(const std::vector& newFactors); - int getMaxNumberOfLevelsRelativeToThis() const; - int getNumberOfCellsAtCurrentLevel() const; - int getNumberOfCellsAtCurrentLevelGhost(int ghostLev) const; - int getNumberOfCellsRecursiveWithOverlap() const; - int getNumberOfCellsRecursiveWithoutOverlap() const; - bool isPatchInNeighborhoodOf(int patchId1, int patchId2, int ghostLev) const; + const std::vector& getFactors() const; + void setFactors(const std::vector& newFactors); + mcIdType getMaxNumberOfLevelsRelativeToThis() const; + mcIdType getNumberOfCellsAtCurrentLevel() const; + mcIdType getNumberOfCellsAtCurrentLevelGhost(mcIdType ghostLev) const; + mcIdType getNumberOfCellsRecursiveWithOverlap() const; + mcIdType getNumberOfCellsRecursiveWithoutOverlap() const; + bool isPatchInNeighborhoodOf(mcIdType patchId1, mcIdType patchId2, mcIdType ghostLev) const; virtual void detachFromFather(); // - int getNumberOfPatches() const; - int getPatchIdFromChildMesh(const MEDCouplingCartesianAMRMeshGen *mesh) const; + mcIdType getNumberOfPatches() const; + mcIdType getPatchIdFromChildMesh(const MEDCouplingCartesianAMRMeshGen *mesh) const; MEDCouplingUMesh *buildUnstructured() const; - DataArrayDouble *extractGhostFrom(int ghostSz, const DataArrayDouble *arr) const; - std::vector getPatchIdsInTheNeighborhoodOf(int patchId, int ghostLev) const; + DataArrayDouble *extractGhostFrom(mcIdType ghostSz, const DataArrayDouble *arr) const; + std::vector getPatchIdsInTheNeighborhoodOf(mcIdType patchId, mcIdType ghostLev) const; MEDCoupling1SGTUMesh *buildMeshFromPatchEnvelop() const; MEDCoupling1SGTUMesh *buildMeshOfDirectChildrenOnly() const; void removeAllPatches(); - void removePatch(int patchId); - void createPatchesFromCriterion(const INTERP_KERNEL::BoxSplittingOptions& bso, const DataArrayByte *criterion, const std::vector& factors); - void createPatchesFromCriterion(const INTERP_KERNEL::BoxSplittingOptions& bso, const DataArrayDouble *criterion, const std::vector& factors, double eps); - DataArrayDouble *createCellFieldOnPatch(int patchId, const DataArrayDouble *cellFieldOnThis) const; - void fillCellFieldOnPatch(int patchId, const DataArrayDouble *cellFieldOnThis, DataArrayDouble *cellFieldOnPatch, bool isConservative=true) const; - void fillCellFieldOnPatchGhost(int patchId, const DataArrayDouble *cellFieldOnThis, DataArrayDouble *cellFieldOnPatch, int ghostLev, bool isConservative=true) const; - void fillCellFieldOnPatchOnlyOnGhostZone(int patchId, const DataArrayDouble *cellFieldOnThis, DataArrayDouble *cellFieldOnPatch, int ghostLev) const; - void fillCellFieldOnPatchOnlyOnGhostZoneWith(int ghostLev, const MEDCouplingCartesianAMRPatch *patchToBeModified, const MEDCouplingCartesianAMRPatch *neighborPatch, DataArrayDouble *cellFieldOnPatch, const DataArrayDouble *cellFieldNeighbor) const; - void fillCellFieldComingFromPatch(int patchId, const DataArrayDouble *cellFieldOnPatch, DataArrayDouble *cellFieldOnThis, bool isConservative=true) const; - void fillCellFieldComingFromPatchGhost(int patchId, const DataArrayDouble *cellFieldOnPatch, DataArrayDouble *cellFieldOnThis, int ghostLev, bool isConservative=true) const; - DataArrayInt *findPatchesInTheNeighborhoodOf(int patchId, int ghostLev) const; + void removePatch(mcIdType patchId); + void createPatchesFromCriterion(const INTERP_KERNEL::BoxSplittingOptions& bso, const DataArrayByte *criterion, const std::vector& factors); + void createPatchesFromCriterion(const INTERP_KERNEL::BoxSplittingOptions& bso, const DataArrayDouble *criterion, const std::vector& factors, double eps); + DataArrayDouble *createCellFieldOnPatch(mcIdType patchId, const DataArrayDouble *cellFieldOnThis) const; + void fillCellFieldOnPatch(mcIdType patchId, const DataArrayDouble *cellFieldOnThis, DataArrayDouble *cellFieldOnPatch, bool isConservative=true) const; + void fillCellFieldOnPatchGhost(mcIdType patchId, const DataArrayDouble *cellFieldOnThis, DataArrayDouble *cellFieldOnPatch, mcIdType ghostLev, bool isConservative=true) const; + void fillCellFieldOnPatchOnlyOnGhostZone(mcIdType patchId, const DataArrayDouble *cellFieldOnThis, DataArrayDouble *cellFieldOnPatch, mcIdType ghostLev) const; + void fillCellFieldOnPatchOnlyOnGhostZoneWith(mcIdType ghostLev, const MEDCouplingCartesianAMRPatch *patchToBeModified, const MEDCouplingCartesianAMRPatch *neighborPatch, DataArrayDouble *cellFieldOnPatch, const DataArrayDouble *cellFieldNeighbor) const; + void fillCellFieldComingFromPatch(mcIdType patchId, const DataArrayDouble *cellFieldOnPatch, DataArrayDouble *cellFieldOnThis, bool isConservative=true) const; + void fillCellFieldComingFromPatchGhost(mcIdType patchId, const DataArrayDouble *cellFieldOnPatch, DataArrayDouble *cellFieldOnThis, mcIdType ghostLev, bool isConservative=true) const; + DataArrayIdType *findPatchesInTheNeighborhoodOf(mcIdType patchId, mcIdType ghostLev) const; std::string buildPythonDumpOfThis() const; %extend { - void addPatch(PyObject *bottomLeftTopRight, const std::vector& factors) + void addPatch(PyObject *bottomLeftTopRight, const std::vector& factors) { - std::vector< std::pair > inp; + std::vector< std::pair > inp; convertPyToVectorPairInt(bottomLeftTopRight,inp); self->addPatch(inp,factors); } @@ -5490,9 +5703,9 @@ namespace MEDCoupling PyObject *getPatches() const { std::vector< const MEDCouplingCartesianAMRPatch *> ps(self->getPatches()); - int sz(ps.size()); + std::size_t sz(ps.size()); PyObject *ret = PyList_New(sz); - for(int i=0;i(ps[i])); if(elt) @@ -5508,7 +5721,7 @@ namespace MEDCoupling return convertCartesianAMRMesh(self->deepCopy(father), SWIG_POINTER_OWN | 0 ); } - MEDCouplingCartesianAMRPatch *getPatchAtPosition(const std::vector& pos) const + MEDCouplingCartesianAMRPatch *getPatchAtPosition(const std::vector& pos) const { const MEDCouplingCartesianAMRPatch *ret(self->getPatchAtPosition(pos)); MEDCouplingCartesianAMRPatch *ret2(const_cast(ret)); @@ -5517,7 +5730,7 @@ namespace MEDCoupling return ret2; } - MEDCouplingCartesianAMRMeshGen *getMeshAtPosition(const std::vector& pos) const + MEDCouplingCartesianAMRMeshGen *getMeshAtPosition(const std::vector& pos) const { const MEDCouplingCartesianAMRMeshGen *ret(self->getMeshAtPosition(pos)); MEDCouplingCartesianAMRMeshGen *ret2(const_cast(ret)); @@ -5528,25 +5741,25 @@ namespace MEDCoupling virtual PyObject *positionRelativeToGodFather() const { - std::vector out1; - std::vector< std::pair > out0(self->positionRelativeToGodFather(out1)); + std::vector out1; + std::vector< std::pair > out0(self->positionRelativeToGodFather(out1)); PyObject *ret(PyTuple_New(2)); PyTuple_SetItem(ret,0,convertFromVectorPairInt(out0)); PyTuple_SetItem(ret,1,convertIntArrToPyList2(out1)); return ret; } - virtual PyObject *retrieveGridsAt(int absoluteLev) const + virtual PyObject *retrieveGridsAt(mcIdType absoluteLev) const { std::vector ps(self->retrieveGridsAt(absoluteLev)); - int sz(ps.size()); + std::size_t sz(ps.size()); PyObject *ret = PyList_New(sz); - for(int i=0;i inp; convertFromPyObjVectorOfObj(recurseArrs,SWIGTYPE_p_MEDCoupling__DataArrayDouble,"DataArrayDouble",inp); @@ -5569,7 +5782,7 @@ namespace MEDCoupling return ret; } - MEDCouplingCartesianAMRPatch *getPatch(int patchId) const + MEDCouplingCartesianAMRPatch *getPatch(mcIdType patchId) const { MEDCouplingCartesianAMRPatch *ret(const_cast(self->getPatch(patchId))); if(ret) @@ -5585,7 +5798,7 @@ namespace MEDCoupling return const_cast(ret); } - MEDCouplingCartesianAMRPatch *__getitem__(int patchId) const + MEDCouplingCartesianAMRPatch *__getitem__(mcIdType patchId) const { if(patchId==self->getNumberOfPatches()) { @@ -5600,26 +5813,26 @@ namespace MEDCoupling return ret; } - void fillCellFieldOnPatchGhostAdv(int patchId, const DataArrayDouble *cellFieldOnThis, int ghostLev, PyObject *arrsOnPatches, bool isConservative=true) const + void fillCellFieldOnPatchGhostAdv(mcIdType patchId, const DataArrayDouble *cellFieldOnThis, mcIdType ghostLev, PyObject *arrsOnPatches, bool isConservative=true) const { std::vector arrsOnPatches2; convertFromPyObjVectorOfObj(arrsOnPatches,SWIGTYPE_p_MEDCoupling__DataArrayDouble,"DataArrayDouble",arrsOnPatches2); self->fillCellFieldOnPatchGhostAdv(patchId,cellFieldOnThis,ghostLev,arrsOnPatches2,isConservative); } - void fillCellFieldOnPatchOnlyGhostAdv(int patchId, int ghostLev, PyObject *arrsOnPatches) const + void fillCellFieldOnPatchOnlyGhostAdv(mcIdType patchId, mcIdType ghostLev, PyObject *arrsOnPatches) const { std::vector arrsOnPatches2; convertFromPyObjVectorOfObj(arrsOnPatches,SWIGTYPE_p_MEDCoupling__DataArrayDouble,"DataArrayDouble",arrsOnPatches2); self->fillCellFieldOnPatchOnlyGhostAdv(patchId,ghostLev,arrsOnPatches2); } - void __delitem__(int patchId) + void __delitem__(mcIdType patchId) { self->removePatch(patchId); } - int __len__() const + mcIdType __len__() const { return self->getNumberOfPatches(); } @@ -5640,15 +5853,15 @@ namespace MEDCoupling { static const char msg0[]="MEDCouplingCartesianAMRMesh::New : error on 'origin' parameter !"; static const char msg1[]="MEDCouplingCartesianAMRMesh::New : error on 'dxyz' parameter !"; - const int *nodeStrctPtr(0); + const mcIdType *nodeStrctPtr(0); const double *originPtr(0),*dxyzPtr(0); - int sw,sz,val0; - std::vector bb0; + mcIdType sw,sz,val0; + std::vector bb0; nodeStrctPtr=convertIntStarLikePyObjToCppIntStar(nodeStrct,sw,sz,val0,bb0); // double val,val2; std::vector bb,bb2; - int sz1,sz2; + mcIdType sz1,sz2; originPtr=convertObjToPossibleCpp5_SingleCompo(origin,sw,val,bb,msg0,false,sz1); dxyzPtr=convertObjToPossibleCpp5_SingleCompo(dxyz,sw,val2,bb2,msg1,false,sz2); // @@ -5659,7 +5872,7 @@ namespace MEDCoupling { std::vector inp0; convertFromPyObjVectorOfObj(bso,SWIGTYPE_p_INTERP_KERNEL__BoxSplittingOptions,"BoxSplittingOptions",inp0); - std::vector< std::vector > inp2; + std::vector< std::vector > inp2; convertPyToVectorOfVectorOfInt(factors,inp2); self->createPatchesFromCriterionML(inp0,criterion,inp2,eps); } @@ -5680,13 +5893,13 @@ namespace MEDCoupling { public: virtual void synchronizeFineToCoarse(); - virtual void synchronizeFineToCoarseBetween(int fromLev, int toLev); + virtual void synchronizeFineToCoarseBetween(mcIdType fromLev, mcIdType toLev); virtual void synchronizeCoarseToFine(); - virtual void synchronizeCoarseToFineBetween(int fromLev, int toLev); + virtual void synchronizeCoarseToFineBetween(mcIdType fromLev, mcIdType toLev); virtual void synchronizeAllGhostZones(); virtual void synchronizeAllGhostZonesOfDirectChidrenOf(const MEDCouplingCartesianAMRMeshGen *mesh); - virtual void synchronizeAllGhostZonesAtASpecifiedLevel(int level); - virtual void synchronizeAllGhostZonesAtASpecifiedLevelUsingOnlyFather(int level); + virtual void synchronizeAllGhostZonesAtASpecifiedLevel(mcIdType level); + virtual void synchronizeAllGhostZonesAtASpecifiedLevelUsingOnlyFather(mcIdType level); virtual void alloc(); virtual void dealloc(); %extend @@ -5704,7 +5917,7 @@ namespace MEDCoupling class MEDCouplingAMRAttribute : public MEDCouplingDataForGodFather, public TimeLabel { public: - int getNumberOfLevels() const; + mcIdType getNumberOfLevels() const; MEDCouplingAMRAttribute *deepCopy() const; MEDCouplingAMRAttribute *deepCpyWithoutGodFather() const; MEDCouplingFieldDouble *buildCellFieldOnRecurseWithoutOverlapWithoutGhost(MEDCouplingCartesianAMRMeshGen *mesh, const std::string& fieldName) const; @@ -5715,7 +5928,7 @@ namespace MEDCoupling std::string writeVTHB(const std::string& fileName) const; %extend { - static MEDCouplingAMRAttribute *New(MEDCouplingCartesianAMRMesh *gf, PyObject *fieldNames, int ghostLev) + static MEDCouplingAMRAttribute *New(MEDCouplingCartesianAMRMesh *gf, PyObject *fieldNames, mcIdType ghostLev) { std::vector< std::pair > fieldNamesCpp0; std::vector< std::pair > > fieldNamesCpp1; @@ -5733,7 +5946,7 @@ namespace MEDCoupling return ret; } - MEDCouplingAMRAttribute(MEDCouplingCartesianAMRMesh *gf, PyObject *fieldNames, int ghostLev) + MEDCouplingAMRAttribute(MEDCouplingCartesianAMRMesh *gf, PyObject *fieldNames, mcIdType ghostLev) { return MEDCoupling_MEDCouplingAMRAttribute_New(gf,fieldNames,ghostLev); } @@ -5756,7 +5969,7 @@ namespace MEDCoupling void spillNatures(PyObject *nfs) { - std::vector inp0; + std::vector inp0; if(!fillIntVector(nfs,inp0)) throw INTERP_KERNEL::Exception("wrap of MEDCouplingAMRAttribute::spillNatures : vector of NatureOfField enum expected !"); std::size_t sz(inp0.size()); @@ -5769,9 +5982,9 @@ namespace MEDCoupling PyObject *retrieveFieldsOn(MEDCouplingCartesianAMRMeshGen *mesh) const { std::vector ret(self->retrieveFieldsOn(mesh)); - int sz((int)ret.size()); + std::size_t sz(ret.size()); PyObject *retPy(PyList_New(sz)); - for(int i=0;i