X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FMEDCoupling_Swig%2FMEDCouplingCommon.i;h=ca7e739462a6ff5de0d77d41ddd2d3af8b1be409;hb=6712a95b385dfb8db6ab119dd2cc0da77f063142;hp=cb4b2205c4a36d843e63c2cb6bf7c8b6a4a6b675;hpb=a019ec6e72f540d3378f3e869c2b19bf4886459c;p=tools%2Fmedcoupling.git diff --git a/src/MEDCoupling_Swig/MEDCouplingCommon.i b/src/MEDCoupling_Swig/MEDCouplingCommon.i index cb4b2205c..ca7e73946 100644 --- a/src/MEDCoupling_Swig/MEDCouplingCommon.i +++ b/src/MEDCoupling_Swig/MEDCouplingCommon.i @@ -1,4 +1,4 @@ -// Copyright (C) 2017 CEA/DEN, EDF R&D +// Copyright (C) 2017-2021 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,15 +27,18 @@ %{ #include "MEDCouplingMemArray.hxx" +#include "MEDCouplingMemArray.txx" #include "MEDCouplingUMesh.hxx" #include "MEDCouplingMappedExtrudedMesh.hxx" #include "MEDCouplingCMesh.hxx" #include "MEDCouplingIMesh.hxx" +#include "MEDCouplingMap.txx" #include "MEDCouplingCurveLinearMesh.hxx" #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" @@ -59,10 +62,35 @@ 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 +#ifdef WIN32 +typedef long long mcPyPtrType; +#else +typedef long mcPyPtrType; +#endif + //////////////////// %typemap(out) MEDCoupling::MEDCouplingMesh* { @@ -247,15 +275,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; @@ -276,6 +313,7 @@ using namespace INTERP_KERNEL; %newobject MEDCoupling::MEDCouplingMesh::buildPartRange; %newobject MEDCoupling::MEDCouplingMesh::giveCellsWithType; %newobject MEDCoupling::MEDCouplingMesh::getCoordinatesAndOwner; +%newobject MEDCoupling::MEDCouplingMesh::computeMeshCenterOfMass; %newobject MEDCoupling::MEDCouplingMesh::computeCellCenterOfMass; %newobject MEDCoupling::MEDCouplingMesh::computeIsoBarycenterOfNodesPerCell; %newobject MEDCoupling::MEDCouplingMesh::buildOrthogonalField; @@ -325,6 +363,7 @@ using namespace INTERP_KERNEL; %newobject MEDCoupling::MEDCouplingUMesh::conformize2D; %newobject MEDCoupling::MEDCouplingUMesh::conformize3D; %newobject MEDCoupling::MEDCouplingUMesh::colinearize2D; +%newobject MEDCoupling::MEDCouplingUMesh::colinearizeKeepingConform2D; %newobject MEDCoupling::MEDCouplingUMesh::rearrange2ConsecutiveCellTypes; %newobject MEDCoupling::MEDCouplingUMesh::sortCellsInMEDFileFrmt; %newobject MEDCoupling::MEDCouplingUMesh::getRenumArrForMEDFileFrmt; @@ -361,6 +400,7 @@ using namespace INTERP_KERNEL; %newobject MEDCoupling::MEDCouplingUMesh::getBoundingBoxForBBTreeFast; %newobject MEDCoupling::MEDCouplingUMesh::getBoundingBoxForBBTree2DQuadratic; %newobject MEDCoupling::MEDCouplingUMesh::getBoundingBoxForBBTree1DQuadratic; +%newobject MEDCoupling::MEDCouplingUMesh::convertDegeneratedCellsAndRemoveFlatOnes; %newobject MEDCoupling::MEDCouplingUMeshCellByTypeEntry::__iter__; %newobject MEDCoupling::MEDCouplingUMeshCellEntry::__iter__; %newobject MEDCoupling::MEDCoupling1GTUMesh::New; @@ -441,6 +481,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();" @@ -460,7 +504,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();" @@ -483,6 +528,9 @@ using namespace INTERP_KERNEL; %nodefaultctor; +// ABN: Instruct SWIG that INTERP_KERNEL::Exception is an exception class and that it should inherit Exception +// on the Python side. Must be put BEFORE the %rename clause: +%exceptionclass INTERP_KERNEL::Exception; %rename (InterpKernelException) INTERP_KERNEL::Exception; %include "MEDCouplingRefCountObject.i" @@ -493,13 +541,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;iprintOptions(); } @@ -563,7 +657,8 @@ namespace MEDCoupling IMAGE_GRID = 12 } MEDCouplingMeshType; - class DataArrayInt; + class DataArrayInt32; + class DataArrayInt64; class DataArrayDouble; class MEDCouplingUMesh; class MEDCouplingCMesh; @@ -580,12 +675,12 @@ namespace MEDCoupling %extend MEDCouplingGaussLocalization { - std::string __str__() const throw(INTERP_KERNEL::Exception) + std::string __str__() const { return self->getStringRepr(); } - std::string __repr__() const throw(INTERP_KERNEL::Exception) + std::string __repr__() const { std::ostringstream oss; oss << "MEDCouplingGaussLocalization C++ instance at " << self << "." << std::endl; oss << self->getStringRepr(); @@ -605,63 +700,69 @@ namespace MEDCoupling void setTime(double val, int iteration, int order); void setTimeUnit(const std::string& unit); std::string getTimeUnit() const; - virtual MEDCouplingMeshType getType() const throw(INTERP_KERNEL::Exception); - bool isStructured() const throw(INTERP_KERNEL::Exception); - virtual MEDCouplingMesh *deepCopy() const throw(INTERP_KERNEL::Exception); - virtual MEDCouplingMesh *clone(bool recDeepCpy) const throw(INTERP_KERNEL::Exception); - virtual bool isEqual(const MEDCouplingMesh *other, double prec) const throw(INTERP_KERNEL::Exception); - virtual bool isEqualWithoutConsideringStr(const MEDCouplingMesh *other, double prec) const throw(INTERP_KERNEL::Exception); - virtual void checkFastEquivalWith(const MEDCouplingMesh *other, double prec) const throw(INTERP_KERNEL::Exception); - virtual void copyTinyStringsFrom(const MEDCouplingMesh *other) throw(INTERP_KERNEL::Exception); - virtual void copyTinyInfoFrom(const MEDCouplingMesh *other) throw(INTERP_KERNEL::Exception); - virtual void checkConsistencyLight() const throw(INTERP_KERNEL::Exception); - virtual void checkConsistency(double eps=1e-12) const throw(INTERP_KERNEL::Exception); - virtual int getNumberOfCells() const throw(INTERP_KERNEL::Exception); - virtual int getNumberOfNodes() const throw(INTERP_KERNEL::Exception); - virtual int getSpaceDimension() const throw(INTERP_KERNEL::Exception); - virtual int getMeshDimension() const throw(INTERP_KERNEL::Exception); - virtual DataArrayDouble *getCoordinatesAndOwner() const throw(INTERP_KERNEL::Exception); - virtual DataArrayDouble *computeCellCenterOfMass() const throw(INTERP_KERNEL::Exception); - virtual DataArrayDouble *computeIsoBarycenterOfNodesPerCell() const throw(INTERP_KERNEL::Exception); - virtual DataArrayInt *giveCellsWithType(INTERP_KERNEL::NormalizedCellType type) const throw(INTERP_KERNEL::Exception); - virtual DataArrayInt *computeNbOfNodesPerCell() const throw(INTERP_KERNEL::Exception); - virtual DataArrayInt *computeNbOfFacesPerCell() const throw(INTERP_KERNEL::Exception); - virtual DataArrayInt *computeEffectiveNbOfNodesPerCell() const throw(INTERP_KERNEL::Exception); - virtual MEDCouplingMesh *buildPartRange(int beginCellIds, int endCellIds, int stepCellIds) const throw(INTERP_KERNEL::Exception); - virtual int getNumberOfCellsWithType(INTERP_KERNEL::NormalizedCellType type) const throw(INTERP_KERNEL::Exception); - virtual INTERP_KERNEL::NormalizedCellType getTypeOfCell(int cellId) const throw(INTERP_KERNEL::Exception); - virtual std::string simpleRepr() const throw(INTERP_KERNEL::Exception); - virtual std::string advancedRepr() const throw(INTERP_KERNEL::Exception); - std::string writeVTK(const std::string& fileName, bool isBinary=true) const throw(INTERP_KERNEL::Exception); + virtual MEDCouplingMeshType getType() const; + bool isStructured() const; + virtual MEDCouplingMesh *deepCopy() const; + virtual MEDCouplingMesh *clone(bool recDeepCpy) const; + virtual bool isEqual(const MEDCouplingMesh *other, double prec) const; + virtual bool isEqualWithoutConsideringStr(const MEDCouplingMesh *other, double prec) const; + virtual void checkFastEquivalWith(const MEDCouplingMesh *other, double prec) const; + virtual void copyTinyStringsFrom(const MEDCouplingMesh *other); + virtual void copyTinyInfoFrom(const MEDCouplingMesh *other); + virtual void checkConsistencyLight() const; + virtual void checkConsistency(double eps=1e-12) const; + virtual int getNumberOfCells() const; + virtual int getNumberOfNodes() const; + virtual int getSpaceDimension() const; + virtual int getMeshDimension() const; + virtual DataArrayDouble *getCoordinatesAndOwner() const; + virtual DataArrayDouble *computeCellCenterOfMass() const; + virtual DataArrayDouble *computeIsoBarycenterOfNodesPerCell() const; + virtual DataArrayIdType *giveCellsWithType(INTERP_KERNEL::NormalizedCellType type) const; + virtual DataArrayIdType *computeNbOfNodesPerCell() const; + virtual DataArrayIdType *computeNbOfFacesPerCell() const; + virtual DataArrayIdType *computeEffectiveNbOfNodesPerCell() const; + virtual MEDCouplingMesh *buildPartRange(int beginCellIds, int endCellIds, int stepCellIds) const; + virtual int getNumberOfCellsWithType(INTERP_KERNEL::NormalizedCellType type) const; + virtual INTERP_KERNEL::NormalizedCellType getTypeOfCell(int cellId) const; + virtual std::string simpleRepr() const; + virtual std::string advancedRepr() const; + std::string writeVTK(const std::string& fileName, bool isBinary=true) const; virtual std::string getVTKFileExtension() const; std::string getVTKFileNameOf(const std::string& fileName) const; // tools - virtual MEDCouplingFieldDouble *getMeasureField(bool isAbs) const throw(INTERP_KERNEL::Exception); - virtual MEDCouplingFieldDouble *getMeasureFieldOnNode(bool isAbs) const throw(INTERP_KERNEL::Exception); - virtual MEDCouplingFieldDouble *fillFromAnalytic(TypeOfField t, int nbOfComp, const std::string& func) const throw(INTERP_KERNEL::Exception); - virtual MEDCouplingFieldDouble *fillFromAnalyticCompo(TypeOfField t, int nbOfComp, const std::string& func) const throw(INTERP_KERNEL::Exception); - virtual MEDCouplingFieldDouble *fillFromAnalyticNamedCompo(TypeOfField t, int nbOfComp, const std::vector& varsOrder, const std::string& func) const throw(INTERP_KERNEL::Exception); - virtual MEDCouplingFieldDouble *buildOrthogonalField() const throw(INTERP_KERNEL::Exception); - virtual MEDCouplingUMesh *buildUnstructured() const throw(INTERP_KERNEL::Exception); - virtual MEDCouplingMesh *mergeMyselfWith(const MEDCouplingMesh *other) const throw(INTERP_KERNEL::Exception); - virtual bool areCompatibleForMerge(const MEDCouplingMesh *other) const throw(INTERP_KERNEL::Exception); - virtual DataArrayInt *simplexize(int policy) throw(INTERP_KERNEL::Exception); - virtual void unserialization(const std::vector& tinyInfoD, const std::vector& tinyInfo, const DataArrayInt *a1, DataArrayDouble *a2, const std::vector& littleStrings) throw(INTERP_KERNEL::Exception); - static MEDCouplingMesh *MergeMeshes(const MEDCouplingMesh *mesh1, const MEDCouplingMesh *mesh2) throw(INTERP_KERNEL::Exception); - static bool IsStaticGeometricType(INTERP_KERNEL::NormalizedCellType type) throw(INTERP_KERNEL::Exception); - static bool IsLinearGeometricType(INTERP_KERNEL::NormalizedCellType type) throw(INTERP_KERNEL::Exception); - static INTERP_KERNEL::NormalizedCellType GetCorrespondingPolyType(INTERP_KERNEL::NormalizedCellType type) throw(INTERP_KERNEL::Exception); - static int GetNumberOfNodesOfGeometricType(INTERP_KERNEL::NormalizedCellType type) throw(INTERP_KERNEL::Exception); - static int GetDimensionOfGeometricType(INTERP_KERNEL::NormalizedCellType type) throw(INTERP_KERNEL::Exception); - static const char *GetReprOfGeometricType(INTERP_KERNEL::NormalizedCellType type) throw(INTERP_KERNEL::Exception); + virtual MEDCouplingFieldDouble *getMeasureField(bool isAbs) const; + virtual MEDCouplingFieldDouble *getMeasureFieldOnNode(bool isAbs) const; + virtual MEDCouplingFieldDouble *fillFromAnalytic(TypeOfField t, int nbOfComp, const std::string& func) const; + virtual MEDCouplingFieldDouble *fillFromAnalyticCompo(TypeOfField t, int nbOfComp, const std::string& func) const; + virtual MEDCouplingFieldDouble *fillFromAnalyticNamedCompo(TypeOfField t, int nbOfComp, const std::vector& varsOrder, const std::string& func) const; + virtual MEDCouplingFieldDouble *buildOrthogonalField() const; + virtual MEDCouplingUMesh *buildUnstructured() const; + virtual MEDCouplingMesh *mergeMyselfWith(const MEDCouplingMesh *other) const; + virtual bool areCompatibleForMerge(const MEDCouplingMesh *other) const; + 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); + static INTERP_KERNEL::NormalizedCellType GetCorrespondingPolyType(INTERP_KERNEL::NormalizedCellType type); + static int GetNumberOfNodesOfGeometricType(INTERP_KERNEL::NormalizedCellType type); + static int GetDimensionOfGeometricType(INTERP_KERNEL::NormalizedCellType type); + static const char *GetReprOfGeometricType(INTERP_KERNEL::NormalizedCellType type); %extend { - std::string __str__() const throw(INTERP_KERNEL::Exception) + std::string __str__() const { return self->simpleRepr(); } + + DataArrayDouble *computeMeshCenterOfMass() const + { + MCAuto ret(self->computeMeshCenterOfMass()); + return ret.retn(); + } - PyObject *getTime() throw(INTERP_KERNEL::Exception) + PyObject *getTime() { int tmp1,tmp2; double tmp0=self->getTime(tmp1,tmp2); @@ -672,7 +773,7 @@ namespace MEDCoupling return res; } - DataArrayDouble *getDirectAccessOfCoordsArrIfInStructure() const throw(INTERP_KERNEL::Exception) + DataArrayDouble *getDirectAccessOfCoordsArrIfInStructure() const { const DataArrayDouble *ret(self->getDirectAccessOfCoordsArrIfInStructure()); DataArrayDouble *ret2(const_cast(ret)); @@ -681,185 +782,178 @@ namespace MEDCoupling return ret2; } - int getCellContainingPoint(PyObject *p, double eps) const throw(INTERP_KERNEL::Exception) + 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); return self->getCellContainingPoint(pos,eps); } - PyObject *getCellsContainingPoints(PyObject *p, int nbOfPoints, double eps) const throw(INTERP_KERNEL::Exception) + PyObject *getCellsContainingPoints(PyObject *p, int nbOfPoints, 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::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; } - PyObject *getCellsContainingPoints(PyObject *p, double eps) const throw(INTERP_KERNEL::Exception) + PyObject *getCellsContainingPointsLinearPartOnlyOnNonDynType(PyObject *p, int nbOfPoints, double eps) const { - MCAuto elts,eltsIndex; + double val; + DataArrayDouble *a; + DataArrayDoubleTuple *aa; + std::vector bb; + mcIdType sw; int spaceDim=self->getSpaceDimension(); - void *da=0; - int res1=SWIG_ConvertPtr(p,&da,SWIGTYPE_p_MEDCoupling__DataArrayDouble, 0 | 0 ); - if (!SWIG_IsOK(res1)) - { - int size; - INTERP_KERNEL::AutoCPtr tmp=convertPyToNewDblArr2(p,&size); - int nbOfPoints=size/spaceDim; - if(size%spaceDim!=0) - { - throw INTERP_KERNEL::Exception("MEDCouplingMesh::getCellsContainingPoints : Invalid list length ! Must be a multiple of self.getSpaceDimension() !"); - } - self->getCellsContainingPoints(tmp,nbOfPoints,eps,elts,eltsIndex); - } - else - { - DataArrayDouble *da2=reinterpret_cast< DataArrayDouble * >(da); - if(!da2) - throw INTERP_KERNEL::Exception("MEDCouplingMesh::getCellsContainingPoints : Not null DataArrayDouble instance expected !"); - da2->checkAllocated(); - int size=da2->getNumberOfTuples(); - int nbOfCompo=da2->getNumberOfComponents(); - if(nbOfCompo!=spaceDim) - { - throw INTERP_KERNEL::Exception("MEDCouplingMesh::getCellsContainingPoints : Invalid DataArrayDouble nb of components ! Expected same as self.getSpaceDimension() !"); - } - self->getCellsContainingPoints(da2->getConstPointer(),size,eps,elts,eltsIndex); - } + 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; + 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 *getCellsContainingPoint(PyObject *p, double eps) const throw(INTERP_KERNEL::Exception) + 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); }; + 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); }; + return Mesh_getCellsContainingPointsLike(p,eps,self,getCellsContainingPointsFunc); + } + + PyObject *getCellsContainingPoint(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 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 throw(INTERP_KERNEL::Exception) + 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) throw(INTERP_KERNEL::Exception) + 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 throw(INTERP_KERNEL::Exception) + 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 throw(INTERP_KERNEL::Exception) + 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 throw(INTERP_KERNEL::Exception) + 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 throw(INTERP_KERNEL::Exception) + 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 throw(INTERP_KERNEL::Exception) + PyObject *getNodeIdsOfCell(int cellId) const { - std::vector conn; + std::vector conn; self->getNodeIdsOfCell(cellId,conn); return convertIntArrToPyList2(conn); } - PyObject *getCoordinatesOfNode(int nodeId) const throw(INTERP_KERNEL::Exception) + PyObject *getCoordinatesOfNode(mcIdType nodeId) const { std::vector coo; self->getCoordinatesOfNode(nodeId,coo); return convertDblArrToPyList2(coo); } - void scale(PyObject *point, double factor) throw(INTERP_KERNEL::Exception) + void scale(PyObject *point, double factor) { double val; 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); self->scale(pointPtr,factor); } - PyObject *getBoundingBox() const throw(INTERP_KERNEL::Exception) + PyObject *getBoundingBox() const { int spaceDim=self->getSpaceDimension(); INTERP_KERNEL::AutoPtr tmp=new double[2*spaceDim]; @@ -868,7 +962,7 @@ namespace MEDCoupling return ret; } - PyObject *isEqualIfNotWhy(const MEDCouplingMesh *other, double prec) const throw(INTERP_KERNEL::Exception) + PyObject *isEqualIfNotWhy(const MEDCouplingMesh *other, double prec) const { std::string ret1; bool ret0=self->isEqualIfNotWhy(other,prec,ret1); @@ -880,16 +974,16 @@ namespace MEDCoupling return ret; } - PyObject *buildPart(PyObject *li) const throw(INTERP_KERNEL::Exception) + 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()); @@ -897,17 +991,17 @@ namespace MEDCoupling return convertMesh(ret, SWIG_POINTER_OWN | 0 ); } - PyObject *buildPartAndReduceNodes(PyObject *li) const throw(INTERP_KERNEL::Exception) + 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()); @@ -915,22 +1009,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 throw(INTERP_KERNEL::Exception) + 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); @@ -938,106 +1032,106 @@ namespace MEDCoupling return res; } - PyObject *getDistributionOfTypes() const throw(INTERP_KERNEL::Exception) + 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 throw(INTERP_KERNEL::Exception) + 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; } - void translate(PyObject *vector) throw(INTERP_KERNEL::Exception) + void translate(PyObject *vector) { double val; 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); self->translate(vectorPtr); } - void rotate(PyObject *center, double alpha) throw(INTERP_KERNEL::Exception) + void rotate(PyObject *center, double alpha) { const char msg[]="Python wrap of MEDCouplingPointSet::rotate : "; double val; 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); } - void rotate(PyObject *center, PyObject *vector, double alpha) throw(INTERP_KERNEL::Exception) + void rotate(PyObject *center, PyObject *vector, double alpha) { const char msg[]="Python wrap of MEDCouplingPointSet::rotate : "; double val,val2; 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 self->rotate(centerPtr,vectorPtr,alpha); } - PyObject *getAllGeoTypes() const throw(INTERP_KERNEL::Exception) + PyObject *getAllGeoTypes() const { std::set result=self->getAllGeoTypes(); std::set::const_iterator iL=result.begin(); @@ -1047,43 +1141,43 @@ namespace MEDCoupling return res; } - virtual PyObject *getTinySerializationInformation() const throw(INTERP_KERNEL::Exception) + 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 throw(INTERP_KERNEL::Exception) + void resizeForUnserialization(const std::vector& tinyInfo, DataArrayIdType *a1, DataArrayDouble *a2) const { std::vector littleStrings; self->resizeForUnserialization(tinyInfo,a1,a2,littleStrings); } - PyObject *__getstate__() const throw(INTERP_KERNEL::Exception) + PyObject *__getstate__() const { PyObject *ret0(MEDCoupling_MEDCouplingMesh_getTinySerializationInformation(self)); PyObject *ret1(MEDCoupling_MEDCouplingMesh_serialize(self)); @@ -1093,26 +1187,26 @@ namespace MEDCoupling return ret; } - void __setstate__(PyObject *inp) throw(INTERP_KERNEL::Exception) + void __setstate__(PyObject *inp) { 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); @@ -1122,10 +1216,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); @@ -1135,7 +1229,7 @@ namespace MEDCoupling self->unserialization(a0,a1,b0,b1,a2); } - static MEDCouplingMesh *MergeMeshes(PyObject *li) throw(INTERP_KERNEL::Exception) + static MEDCouplingMesh *MergeMeshes(PyObject *li) { std::vector tmp; convertFromPyObjVectorOfObj(li,SWIGTYPE_p_MEDCoupling__MEDCouplingMesh,"MEDCouplingMesh",tmp); @@ -1155,7 +1249,7 @@ namespace MEDCoupling class MEDCouplingNatureOfField { public: - static const char *GetRepr(NatureOfField nat) throw(INTERP_KERNEL::Exception); + static const char *GetRepr(NatureOfField nat); static std::string GetReprNoThrow(NatureOfField nat); static std::string GetAllPossibilitiesStr(); }; @@ -1170,41 +1264,41 @@ namespace MEDCoupling { public: MEDCouplingGaussLocalization(INTERP_KERNEL::NormalizedCellType type, const std::vector& refCoo, - const std::vector& gsCoo, const std::vector& w) throw(INTERP_KERNEL::Exception); - MEDCouplingGaussLocalization(INTERP_KERNEL::NormalizedCellType typ) throw(INTERP_KERNEL::Exception); - INTERP_KERNEL::NormalizedCellType getType() const throw(INTERP_KERNEL::Exception); - void setType(INTERP_KERNEL::NormalizedCellType typ) throw(INTERP_KERNEL::Exception); - int getNumberOfGaussPt() const throw(INTERP_KERNEL::Exception); - int getDimension() const throw(INTERP_KERNEL::Exception); - int getNumberOfPtsInRefCell() const throw(INTERP_KERNEL::Exception); - std::string getStringRepr() const throw(INTERP_KERNEL::Exception); - void checkConsistencyLight() const throw(INTERP_KERNEL::Exception); - bool isEqual(const MEDCouplingGaussLocalization& other, double eps) const throw(INTERP_KERNEL::Exception); + const std::vector& gsCoo, const std::vector& w); + MEDCouplingGaussLocalization(INTERP_KERNEL::NormalizedCellType typ); + INTERP_KERNEL::NormalizedCellType getType() const; + void setType(INTERP_KERNEL::NormalizedCellType typ); + int getNumberOfGaussPt() const; + int getDimension() const; + int getNumberOfPtsInRefCell() const; + std::string getStringRepr() const; + void checkConsistencyLight() const; + bool isEqual(const MEDCouplingGaussLocalization& other, double eps) const; // - const std::vector& getRefCoords() const throw(INTERP_KERNEL::Exception); - double getRefCoord(int ptIdInCell, int comp) const throw(INTERP_KERNEL::Exception); - const std::vector& getGaussCoords() const throw(INTERP_KERNEL::Exception); - double getGaussCoord(int gaussPtIdInCell, int comp) const throw(INTERP_KERNEL::Exception); - const std::vector& getWeights() const throw(INTERP_KERNEL::Exception); - double getWeight(int gaussPtIdInCell, double newVal) const throw(INTERP_KERNEL::Exception); - void setRefCoord(int ptIdInCell, int comp, double newVal) throw(INTERP_KERNEL::Exception); - void setGaussCoord(int gaussPtIdInCell, int comp, double newVal) throw(INTERP_KERNEL::Exception); - void setWeight(int gaussPtIdInCell, double newVal) throw(INTERP_KERNEL::Exception); - void setRefCoords(const std::vector& refCoo) throw(INTERP_KERNEL::Exception); - void setGaussCoords(const std::vector& gsCoo) throw(INTERP_KERNEL::Exception); - void setWeights(const std::vector& w) throw(INTERP_KERNEL::Exception); + const std::vector& getRefCoords() const; + double getRefCoord(int ptIdInCell, int comp) const; + const std::vector& getGaussCoords() const; + double getGaussCoord(int gaussPtIdInCell, int comp) const; + const std::vector& getWeights() const; + double getWeight(int gaussPtIdInCell, double newVal) const; + void setRefCoord(int ptIdInCell, int comp, double newVal); + void setGaussCoord(int gaussPtIdInCell, int comp, double newVal); + void setWeight(int gaussPtIdInCell, double newVal); + void setRefCoords(const std::vector& refCoo); + void setGaussCoords(const std::vector& gsCoo); + void setWeights(const std::vector& w); // static bool AreAlmostEqual(const std::vector& v1, const std::vector& v2, double eps); // %extend { - DataArrayDouble *localizePtsInRefCooForEachCell(const DataArrayDouble *ptsInRefCoo, const MEDCouplingUMesh *mesh) const throw(INTERP_KERNEL::Exception) + DataArrayDouble *localizePtsInRefCooForEachCell(const DataArrayDouble *ptsInRefCoo, const MEDCouplingUMesh *mesh) const { MCAuto ret(self->localizePtsInRefCooForEachCell(ptsInRefCoo,mesh)); return ret.retn(); } - MEDCouplingUMesh *buildRefCell() const throw(INTERP_KERNEL::Exception) + MEDCouplingUMesh *buildRefCell() const { MCAuto ret(self->buildRefCell()); return ret.retn(); @@ -1215,81 +1309,86 @@ namespace MEDCoupling class MEDCouplingSkyLineArray { public: - static MEDCouplingSkyLineArray *BuildFromPolyhedronConn( const DataArrayInt* c, const DataArrayInt* cI ) throw(INTERP_KERNEL::Exception); + 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; int getLength() const; - void deletePack(const int i, const int j) throw(INTERP_KERNEL::Exception); + void deletePack(const int i, const int j); - void deleteSimplePack(const int i) throw(INTERP_KERNEL::Exception); - void deleteSimplePacks(const DataArrayInt* idx) throw(INTERP_KERNEL::Exception); + void deleteSimplePack(const int i); + void deleteSimplePacks(const DataArrayIdType* idx); + + MEDCouplingSkyLineArray *groupPacks(const DataArrayIdType *indexedPacks) const; + MEDCouplingSkyLineArray *uniqueNotSortedByPack() const; + + MEDCouplingSkyLineArray *deepCopy() const; %extend { - MEDCouplingSkyLineArray() throw(INTERP_KERNEL::Exception) + MEDCouplingSkyLineArray() { return MEDCouplingSkyLineArray::New(); } - MEDCouplingSkyLineArray( const std::vector& index, const std::vector& value) throw(INTERP_KERNEL::Exception) + MEDCouplingSkyLineArray( const std::vector& index, const std::vector& value) { return MEDCouplingSkyLineArray::New(index, value); } - MEDCouplingSkyLineArray( DataArrayInt* index, DataArrayInt* value ) throw(INTERP_KERNEL::Exception) + MEDCouplingSkyLineArray( DataArrayIdType* index, DataArrayIdType* value ) { return MEDCouplingSkyLineArray::New(index, value); } - MEDCouplingSkyLineArray( const MEDCouplingSkyLineArray & other ) throw(INTERP_KERNEL::Exception) + MEDCouplingSkyLineArray( const MEDCouplingSkyLineArray & other ) { return MEDCouplingSkyLineArray::New(other); } - std::string __str__() const throw(INTERP_KERNEL::Exception) + std::string __str__() const { 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 throw(INTERP_KERNEL::Exception) + 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 throw(INTERP_KERNEL::Exception) + PyObject *findPackIds(PyObject *superPackIndices, PyObject *pack) const { - std::vector vpack, vspIdx, out; + std::vector vpack, vspIdx, out; convertPyToNewIntArr3(superPackIndices,vspIdx); convertPyToNewIntArr3(pack,vpack); @@ -1298,44 +1397,61 @@ namespace MEDCoupling return convertIntArrToPyList2(out); } - void pushBackPack(const int i, PyObject *pack) throw(INTERP_KERNEL::Exception) + 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) throw(INTERP_KERNEL::Exception) + 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) throw(INTERP_KERNEL::Exception) + 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) throw(INTERP_KERNEL::Exception) + 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 throw(INTERP_KERNEL::Exception) + 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; + } } }; } @@ -1349,64 +1465,64 @@ namespace MEDCoupling class MEDCouplingPointSet : public MEDCoupling::MEDCouplingMesh { public: - void setCoords(const DataArrayDouble *coords) throw(INTERP_KERNEL::Exception); - DataArrayDouble *getCoordinatesAndOwner() const throw(INTERP_KERNEL::Exception); - bool areCoordsEqual(const MEDCouplingPointSet& other, double prec) const throw(INTERP_KERNEL::Exception); - void zipCoords() throw(INTERP_KERNEL::Exception); - double getCaracteristicDimension() const throw(INTERP_KERNEL::Exception); - void recenterForMaxPrecision(double eps) throw(INTERP_KERNEL::Exception); - void changeSpaceDimension(int newSpaceDim, double dftVal=0.) throw(INTERP_KERNEL::Exception); - void tryToShareSameCoords(const MEDCouplingPointSet& other, double epsilon) throw(INTERP_KERNEL::Exception); - virtual void shallowCopyConnectivityFrom(const MEDCouplingPointSet *other) throw(INTERP_KERNEL::Exception); - virtual MEDCouplingPointSet *buildPartOfMySelfSlice(int start, int end, int step) const throw(INTERP_KERNEL::Exception); - virtual void tryToShareSameCoordsPermute(const MEDCouplingPointSet& other, double epsilon) throw(INTERP_KERNEL::Exception); - static DataArrayDouble *MergeNodesArray(const MEDCouplingPointSet *m1, const MEDCouplingPointSet *m2) throw(INTERP_KERNEL::Exception); - static MEDCouplingPointSet *BuildInstanceFromMeshType(MEDCouplingMeshType type) throw(INTERP_KERNEL::Exception); - static DataArrayInt *ComputeNbOfInteractionsWithSrcCells(const MEDCouplingPointSet *srcMesh, const MEDCouplingPointSet *trgMesh, double eps) throw(INTERP_KERNEL::Exception); - virtual DataArrayInt *computeFetchedNodeIds() const throw(INTERP_KERNEL::Exception); - virtual int getNumberOfNodesInCell(int cellId) const throw(INTERP_KERNEL::Exception); - virtual MEDCouplingPointSet *buildBoundaryMesh(bool keepCoords) const throw(INTERP_KERNEL::Exception); - virtual DataArrayInt *getCellsInBoundingBox(const INTERP_KERNEL::DirectedBoundingBox& bbox, double eps) throw(INTERP_KERNEL::Exception); - virtual DataArrayInt *zipCoordsTraducer() throw(INTERP_KERNEL::Exception); - virtual DataArrayInt *findBoundaryNodes() const; - virtual DataArrayInt *zipConnectivityTraducer(int compType, int startCellId=0) throw(INTERP_KERNEL::Exception); - virtual MEDCouplingPointSet *mergeMyselfWithOnSameCoords(const MEDCouplingPointSet *other) const throw(INTERP_KERNEL::Exception); - virtual void checkFullyDefined() const throw(INTERP_KERNEL::Exception); - virtual bool isEmptyMesh(const std::vector& tinyInfo) const throw(INTERP_KERNEL::Exception); - virtual MEDCouplingPointSet *deepCopyConnectivityOnly() const throw(INTERP_KERNEL::Exception); - virtual DataArrayDouble *getBoundingBoxForBBTree(double arcDetEps=1e-12) const throw(INTERP_KERNEL::Exception); - virtual void renumberNodesWithOffsetInConn(int offset) throw(INTERP_KERNEL::Exception); - virtual bool areAllNodesFetched() const throw(INTERP_KERNEL::Exception); - virtual MEDCouplingFieldDouble *computeDiameterField() const throw(INTERP_KERNEL::Exception); - virtual void invertOrientationOfAllCells() throw(INTERP_KERNEL::Exception); + void setCoords(const DataArrayDouble *coords); + DataArrayDouble *getCoordinatesAndOwner() const; + bool areCoordsEqual(const MEDCouplingPointSet& other, double prec) const; + void zipCoords(); + double getCaracteristicDimension() const; + void recenterForMaxPrecision(double eps); + void changeSpaceDimension(int newSpaceDim, double dftVal=0.); + void tryToShareSameCoords(const MEDCouplingPointSet& other, double epsilon); + virtual void shallowCopyConnectivityFrom(const MEDCouplingPointSet *other); + virtual MEDCouplingPointSet *buildPartOfMySelfSlice(int start, int end, int step) const; + virtual void tryToShareSameCoordsPermute(const MEDCouplingPointSet& other, double epsilon); + static DataArrayDouble *MergeNodesArray(const MEDCouplingPointSet *m1, const MEDCouplingPointSet *m2); + static MEDCouplingPointSet *BuildInstanceFromMeshType(MEDCouplingMeshType type); + 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 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 MEDCouplingPointSet *deepCopyConnectivityOnly() const; + virtual DataArrayDouble *getBoundingBoxForBBTree(double arcDetEps=1e-12) const; + virtual void renumberNodesWithOffsetInConn(int offset); + virtual bool areAllNodesFetched() const; + virtual MEDCouplingFieldDouble *computeDiameterField() const; + virtual void invertOrientationOfAllCells(); %extend { - std::string __str__() const throw(INTERP_KERNEL::Exception) + std::string __str__() const { return self->simpleRepr(); } - PyObject *buildNewNumberingFromCommonNodesFormat(const DataArrayInt *comm, const DataArrayInt *commIndex) const throw(INTERP_KERNEL::Exception) + 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 throw(INTERP_KERNEL::Exception) + 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; } - PyObject *getCoords() throw(INTERP_KERNEL::Exception) + PyObject *getCoords() { DataArrayDouble *ret1=self->getCoords(); if (ret1) @@ -1414,16 +1530,16 @@ namespace MEDCoupling return SWIG_NewPointerObj((void*)ret1,SWIGTYPE_p_MEDCoupling__DataArrayDouble,SWIG_POINTER_OWN | 0); } - PyObject *buildPartOfMySelf(PyObject *li, bool keepCoords=true) const throw(INTERP_KERNEL::Exception) + 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()); @@ -1431,16 +1547,16 @@ namespace MEDCoupling return convertMesh(ret, SWIG_POINTER_OWN | 0 ); } - PyObject *buildPartOfMySelfNode(PyObject *li, bool fullyIn) const throw(INTERP_KERNEL::Exception) + 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()); @@ -1448,16 +1564,16 @@ namespace MEDCoupling return convertMesh(ret, SWIG_POINTER_OWN | 0 ); } - virtual PyObject *buildPartOfMySelfKeepCoords(PyObject *li) const throw(INTERP_KERNEL::Exception) + 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()); @@ -1465,22 +1581,22 @@ namespace MEDCoupling return convertMesh(ret, SWIG_POINTER_OWN | 0 ); } - virtual PyObject *buildPartOfMySelfKeepCoordsSlice(int start, int end, int step) const throw(INTERP_KERNEL::Exception) + virtual PyObject *buildPartOfMySelfKeepCoordsSlice(mcIdType start, mcIdType end, mcIdType step) const { MEDCouplingPointSet *ret=self->buildPartOfMySelfKeepCoordsSlice(start,end,step); return convertMesh(ret, SWIG_POINTER_OWN | 0 ); } - PyObject *buildFacePartOfMySelfNode(PyObject *li, bool fullyIn) const throw(INTERP_KERNEL::Exception) + 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()); @@ -1488,135 +1604,135 @@ namespace MEDCoupling return convertMesh(ret, SWIG_POINTER_OWN | 0 ); } - void renumberNodes(PyObject *li, int newNbOfNodes) throw(INTERP_KERNEL::Exception) + 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) throw(INTERP_KERNEL::Exception) + 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); } - PyObject *findNodesOnLine(PyObject *pt, PyObject *vec, double eps) const throw(INTERP_KERNEL::Exception) + PyObject *findNodesOnLine(PyObject *pt, PyObject *vec, double eps) const { int spaceDim=self->getSpaceDimension(); double val,val2; 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 throw(INTERP_KERNEL::Exception) + PyObject *findNodesOnPlane(PyObject *pt, PyObject *vec, double eps) const { int spaceDim=self->getSpaceDimension(); double val,val2; 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 throw(INTERP_KERNEL::Exception) + PyObject *getNodeIdsNearPoint(PyObject *pt, 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 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 throw(INTERP_KERNEL::Exception) + 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 throw(INTERP_KERNEL::Exception) + 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; } - PyObject *getCellsInBoundingBox(PyObject *bbox, double eps) const throw(INTERP_KERNEL::Exception) + PyObject *getCellsInBoundingBox(PyObject *bbox, 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 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) throw(INTERP_KERNEL::Exception) + 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) { @@ -1627,114 +1743,123 @@ 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 throw(INTERP_KERNEL::Exception) + virtual PyObject *findCommonCells(int compType, mcIdType startCellId=0) const { - DataArrayInt *v0=0,*v1=0; + 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; } - virtual void renumberNodesInConn(PyObject *li) throw(INTERP_KERNEL::Exception) + virtual void renumberNodesInConn(PyObject *li) { - void *da=0; - int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_MEDCoupling__DataArrayInt, 0 | 0 ); + void *da(nullptr); + { + int res1(SWIG_ConvertPtr(li,&da,SWIGTYPE_p_MEDCoupling__MapII, 0 | 0 )); + if(SWIG_IsOK(res1)) + { + MapII *da2(reinterpret_cast(da)); + self->renumberNodesInConn(da2->data()); + return ; + } + } + 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()); } } - virtual PyObject *getNodeIdsInUse() const throw(INTERP_KERNEL::Exception) + 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=0; + 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; } - virtual PyObject *mergeNodes(double precision) throw(INTERP_KERNEL::Exception) + 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) throw(INTERP_KERNEL::Exception) + 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 throw(INTERP_KERNEL::Exception) + 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); } } - MEDCouplingPointSet *__getitem__(PyObject *listOrDataArrI) throw(INTERP_KERNEL::Exception) + 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) { @@ -1752,7 +1877,7 @@ namespace MEDCoupling { if(nbc+singleVal>0) { - int tmp=nbc+singleVal; + mcIdType tmp=nbc+singleVal; return self->buildPartOfMySelf(&tmp,&tmp+1,true); } else @@ -1779,25 +1904,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) throw(INTERP_KERNEL::Exception) + 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, @@ -1807,22 +1932,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) throw(INTERP_KERNEL::Exception) + 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, @@ -1843,17 +1968,17 @@ namespace MEDCoupling INTERP_KERNEL::NormalizedCellType getType() const; %extend { - std::string __str__() const throw(INTERP_KERNEL::Exception) + std::string __str__() const { return self->repr(); } - PyObject *getAllConn() const throw(INTERP_KERNEL::Exception) + 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 throw(INTERP_KERNEL::Exception); - DataArrayInt *findCellIdsOnBoundary() const throw(INTERP_KERNEL::Exception); - MEDCouplingUMesh *computeSkin() const throw(INTERP_KERNEL::Exception); - bool checkConsecutiveCellTypes() const throw(INTERP_KERNEL::Exception); - bool checkConsecutiveCellTypesForMEDFileFrmt() const throw(INTERP_KERNEL::Exception); - DataArrayInt *rearrange2ConsecutiveCellTypes() throw(INTERP_KERNEL::Exception); - DataArrayInt *sortCellsInMEDFileFrmt() throw(INTERP_KERNEL::Exception); - DataArrayInt *getRenumArrForMEDFileFrmt() const throw(INTERP_KERNEL::Exception); - DataArrayInt *convertCellArrayPerGeoType(const DataArrayInt *da) const throw(INTERP_KERNEL::Exception); - MEDCouplingUMesh *buildDescendingConnectivity(DataArrayInt *desc, DataArrayInt *descIndx, DataArrayInt *revDesc, DataArrayInt *revDescIndx) const throw(INTERP_KERNEL::Exception); - MEDCouplingUMesh *buildDescendingConnectivity2(DataArrayInt *desc, DataArrayInt *descIndx, DataArrayInt *revDesc, DataArrayInt *revDescIndx) const throw(INTERP_KERNEL::Exception); - MEDCouplingUMesh *explode3DMeshTo1D(DataArrayInt *desc, DataArrayInt *descIndx, DataArrayInt *revDesc, DataArrayInt *revDescIndx) const throw(INTERP_KERNEL::Exception); - MEDCouplingUMesh *explodeMeshIntoMicroEdges(DataArrayInt *desc, DataArrayInt *descIndx, DataArrayInt *revDesc, DataArrayInt *revDescIndx) const throw(INTERP_KERNEL::Exception); - void orientCorrectlyPolyhedrons() throw(INTERP_KERNEL::Exception); - bool isPresenceOfQuadratic() const throw(INTERP_KERNEL::Exception); - bool isFullyQuadratic() const throw(INTERP_KERNEL::Exception); - MEDCouplingFieldDouble *buildDirectionVectorField() const throw(INTERP_KERNEL::Exception); - bool isContiguous1D() const throw(INTERP_KERNEL::Exception); - void tessellate2D(double eps) throw(INTERP_KERNEL::Exception); - void convertQuadraticCellsToLinear() throw(INTERP_KERNEL::Exception); - DataArrayInt *convertLinearCellsToQuadratic(int conversionType=0) throw(INTERP_KERNEL::Exception); - void convertDegeneratedCells() throw(INTERP_KERNEL::Exception); - bool areOnlySimplexCells() const throw(INTERP_KERNEL::Exception); - MEDCouplingFieldDouble *getEdgeRatioField() const throw(INTERP_KERNEL::Exception); - MEDCouplingFieldDouble *getAspectRatioField() const throw(INTERP_KERNEL::Exception); - MEDCouplingFieldDouble *getWarpField() const throw(INTERP_KERNEL::Exception); - MEDCouplingFieldDouble *getSkewField() const throw(INTERP_KERNEL::Exception); - DataArrayDouble *computePlaneEquationOf3DFaces() const throw(INTERP_KERNEL::Exception); - DataArrayInt *convexEnvelop2D() throw(INTERP_KERNEL::Exception); - std::string cppRepr() const throw(INTERP_KERNEL::Exception); - DataArrayInt *findAndCorrectBadOriented3DExtrudedCells() throw(INTERP_KERNEL::Exception); - DataArrayInt *findAndCorrectBadOriented3DCells() throw(INTERP_KERNEL::Exception); - MEDCoupling::MEDCoupling1GTUMesh *convertIntoSingleGeoTypeMesh() const throw(INTERP_KERNEL::Exception); - MEDCouplingSkyLineArray *generateGraph() const throw(INTERP_KERNEL::Exception); - DataArrayInt *convertNodalConnectivityToStaticGeoTypeMesh() const throw(INTERP_KERNEL::Exception); - DataArrayInt *buildUnionOf2DMesh() const throw(INTERP_KERNEL::Exception); - DataArrayInt *buildUnionOf3DMesh() const throw(INTERP_KERNEL::Exception); - DataArrayInt *orderConsecutiveCells1D() const throw(INTERP_KERNEL::Exception); - DataArrayDouble *getBoundingBoxForBBTreeFast() const throw(INTERP_KERNEL::Exception); - DataArrayDouble *getBoundingBoxForBBTree2DQuadratic(double arcDetEps=1e-12) const throw(INTERP_KERNEL::Exception); - DataArrayDouble *getBoundingBoxForBBTree1DQuadratic(double arcDetEps=1e-12) const throw(INTERP_KERNEL::Exception); - void changeOrientationOfCells() throw(INTERP_KERNEL::Exception); - int split2DCells(const DataArrayInt *desc, const DataArrayInt *descI, const DataArrayInt *subNodesInSeg, const DataArrayInt *subNodesInSegI, const DataArrayInt *midOpt=0, const DataArrayInt *midOptI=0) throw(INTERP_KERNEL::Exception); - static MEDCouplingUMesh *Build0DMeshFromCoords(DataArrayDouble *da) throw(INTERP_KERNEL::Exception); - static MEDCouplingUMesh *MergeUMeshes(const MEDCouplingUMesh *mesh1, const MEDCouplingUMesh *mesh2) throw(INTERP_KERNEL::Exception); - static MEDCouplingUMesh *MergeUMeshesOnSameCoords(const MEDCouplingUMesh *mesh1, const MEDCouplingUMesh *mesh2) throw(INTERP_KERNEL::Exception); - static DataArrayInt *ComputeSpreadZoneGradually(const DataArrayInt *arrIn, const DataArrayInt *arrIndxIn) throw(INTERP_KERNEL::Exception); - static DataArrayInt *ComputeRangesFromTypeDistribution(const std::vector& code) throw(INTERP_KERNEL::Exception); + DataArrayIdType *conformize2D(double eps); + DataArrayIdType *conformize3D(double eps); + DataArrayIdType *colinearize2D(double eps); + DataArrayIdType *colinearizeKeepingConform2D(double eps); + void shiftNodeNumbersInConn(int delta); + std::vector getQuadraticStatus() const; + DataArrayIdType *findCellIdsOnBoundary() const; + MEDCouplingUMesh *computeSkin() const; + bool checkConsecutiveCellTypes() const; + bool checkConsecutiveCellTypesForMEDFileFrmt() 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; + MEDCouplingFieldDouble *buildDirectionVectorField() const; + bool isContiguous1D() const; + void tessellate2D(double eps); + void convertQuadraticCellsToLinear(); + DataArrayIdType *convertLinearCellsToQuadratic(int conversionType=0); + void convertDegeneratedCells(); + DataArrayIdType *convertDegeneratedCellsAndRemoveFlatOnes(); + bool removeDegenerated1DCells(); + bool areOnlySimplexCells() const; + MEDCouplingFieldDouble *getEdgeRatioField() const; + MEDCouplingFieldDouble *getAspectRatioField() const; + MEDCouplingFieldDouble *getWarpField() const; + MEDCouplingFieldDouble *getSkewField() const; + DataArrayDouble *computePlaneEquationOf3DFaces() const; + DataArrayIdType *convexEnvelop2D(); + std::string cppRepr() const; + DataArrayIdType *findAndCorrectBadOriented3DExtrudedCells(); + DataArrayIdType *findAndCorrectBadOriented3DCells(); + MEDCoupling::MEDCoupling1GTUMesh *convertIntoSingleGeoTypeMesh() const; + MEDCouplingSkyLineArray *generateGraph() 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 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 DataArrayIdType *ComputeSpreadZoneGradually(const DataArrayIdType *arrIn, const DataArrayIdType *arrIndxIn); + static DataArrayIdType *ComputeRangesFromTypeDistribution(const std::vector& code); %extend { - MEDCouplingUMesh() throw(INTERP_KERNEL::Exception) + MEDCouplingUMesh() { return MEDCouplingUMesh::New(); } - MEDCouplingUMesh(const char *meshName, int meshDim) throw(INTERP_KERNEL::Exception) + MEDCouplingUMesh(const char *meshName, int meshDim) { return MEDCouplingUMesh::New(meshName,meshDim); } - std::string __str__() const throw(INTERP_KERNEL::Exception) + std::string __str__() const { return self->simpleRepr(); } - std::string __repr__() const throw(INTERP_KERNEL::Exception) + std::string __repr__() const { std::ostringstream oss; self->reprQuickOverview(oss); return oss.str(); } - MEDCouplingUMeshCellIterator *__iter__() throw(INTERP_KERNEL::Exception) + MEDCouplingUMeshCellIterator *__iter__() { return self->cellIterator(); } - static MEDCouplingUMesh *Build1DMeshFromCoords(DataArrayDouble *da) throw(INTERP_KERNEL::Exception) + static MEDCouplingUMesh *Build1DMeshFromCoords(DataArrayDouble *da) { MCAuto ret(MEDCouplingUMesh::Build1DMeshFromCoords(da)); return ret.retn(); } - PyObject *getAllGeoTypesSorted() const throw(INTERP_KERNEL::Exception) + PyObject *getAllGeoTypesSorted() const { std::vector result=self->getAllGeoTypesSorted(); std::vector::const_iterator iL=result.begin(); @@ -2042,14 +2172,14 @@ namespace MEDCoupling return res; } - void setPartOfMySelf(PyObject *li, const MEDCouplingUMesh& otherOnSameCoordsThanThis) throw(INTERP_KERNEL::Exception) - { - int sw; - int singleVal; - std::vector multiVal; - std::pair > slic; - MEDCoupling::DataArrayInt *daIntTyypp=0; - int nbc=self->getNumberOfCells(); + void setPartOfMySelf(PyObject *li, const MEDCouplingUMesh& otherOnSameCoordsThanThis) + { + 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) { @@ -2070,7 +2200,7 @@ namespace MEDCoupling { if(nbc+singleVal>0) { - int tmp=nbc+singleVal; + mcIdType tmp=nbc+singleVal; self->setPartOfMySelf(&tmp,&tmp+1,otherOnSameCoordsThanThis); break; } @@ -2096,18 +2226,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) throw(INTERP_KERNEL::Exception) + 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) { @@ -2128,7 +2258,7 @@ namespace MEDCoupling { if(nbc+singleVal>0) { - int tmp=nbc+singleVal; + mcIdType tmp=nbc+singleVal; self->setPartOfMySelf(&tmp,&tmp+1,otherOnSameCoordsThanThis); break; } @@ -2159,15 +2289,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) throw(INTERP_KERNEL::Exception) + 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 << " !"; @@ -2176,63 +2306,63 @@ namespace MEDCoupling self->insertNextCell(type,size,tmp); } - void insertNextCell(INTERP_KERNEL::NormalizedCellType type, PyObject *li) throw(INTERP_KERNEL::Exception) + 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() throw(INTERP_KERNEL::Exception) + DataArrayIdType *getNodalConnectivity() { - DataArrayInt *ret=self->getNodalConnectivity(); + DataArrayIdType *ret=self->getNodalConnectivity(); if(ret) ret->incrRef(); return ret; } - DataArrayInt *getNodalConnectivityIndex() throw(INTERP_KERNEL::Exception) + 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) throw(INTERP_KERNEL::Exception) + 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) throw(INTERP_KERNEL::Exception) + 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; } - PyObject *distanceToPoint(PyObject *point) const throw(INTERP_KERNEL::Exception) + PyObject *distanceToPoint(PyObject *point) const { double val; 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)); @@ -2240,120 +2370,120 @@ namespace MEDCoupling return ret; } - PyObject *distanceToPoints(const DataArrayDouble *pts) const throw(INTERP_KERNEL::Exception) + 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) throw(INTERP_KERNEL::Exception) + 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) throw(INTERP_KERNEL::Exception) + 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 throw(INTERP_KERNEL::Exception) + 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) throw(INTERP_KERNEL::Exception) + 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 throw(INTERP_KERNEL::Exception) + 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 throw(INTERP_KERNEL::Exception) + 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 throw(INTERP_KERNEL::Exception) + 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 throw(INTERP_KERNEL::Exception) + 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 throw(INTERP_KERNEL::Exception) + 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) throw(INTERP_KERNEL::Exception) + 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) { @@ -2364,17 +2494,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) throw(INTERP_KERNEL::Exception) + 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) { @@ -2385,54 +2515,54 @@ 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) throw(INTERP_KERNEL::Exception) + 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 throw(INTERP_KERNEL::Exception) + 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 throw(INTERP_KERNEL::Exception) + 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; } - static PyObject *AggregateSortedByTypeMeshesOnSameCoords(PyObject *ms) throw(INTERP_KERNEL::Exception) + static PyObject *AggregateSortedByTypeMeshesOnSameCoords(PyObject *ms) { 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; } - static PyObject *MergeUMeshesOnSameCoords(PyObject *ms) throw(INTERP_KERNEL::Exception) + static PyObject *MergeUMeshesOnSameCoords(PyObject *ms) { std::vector meshes; convertFromPyObjVectorOfObj(ms,SWIGTYPE_p_MEDCoupling__MEDCouplingUMesh,"MEDCouplingUMesh",meshes); @@ -2440,241 +2570,80 @@ namespace MEDCoupling return convertMesh(ret, SWIG_POINTER_OWN | 0 ); } - static PyObject *FuseUMeshesOnSameCoords(PyObject *ms, int compType) throw(INTERP_KERNEL::Exception) + 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); return ret; } - static void PutUMeshesOnSameAggregatedCoords(PyObject *ms) throw(INTERP_KERNEL::Exception) + static void PutUMeshesOnSameAggregatedCoords(PyObject *ms) { std::vector meshes; convertFromPyObjVectorOfObj(ms,SWIGTYPE_p_MEDCoupling__MEDCouplingUMesh,"MEDCouplingUMesh",meshes); MEDCouplingUMesh::PutUMeshesOnSameAggregatedCoords(meshes); } - static void MergeNodesOnUMeshesSharingSameCoords(PyObject *ms, double eps) throw(INTERP_KERNEL::Exception) + static void MergeNodesOnUMeshesSharingSameCoords(PyObject *ms, double eps) { std::vector meshes; convertFromPyObjVectorOfObj(ms,SWIGTYPE_p_MEDCoupling__MEDCouplingUMesh,"MEDCouplingUMesh",meshes); MEDCouplingUMesh::MergeNodesOnUMeshesSharingSameCoords(meshes,eps); } - static bool RemoveIdsFromIndexedArrays(PyObject *li, DataArrayInt *arr, DataArrayInt *arrIndx, int offsetForRemoval=0) throw(INTERP_KERNEL::Exception) - { - int sw; - int singleVal; - std::vector multiVal; - std::pair > slic; - MEDCoupling::DataArrayInt *daIntTyypp=0; - if(!arrIndx) - throw INTERP_KERNEL::Exception("MEDCouplingUMesh::RemoveIdsFromIndexedArrays : null pointer as arrIndex !"); - convertIntStarOrSliceLikePyObjToCpp(li,arrIndx->getNumberOfTuples()-1,sw,singleVal,multiVal,slic,daIntTyypp); - switch(sw) - { - case 1: - return MEDCouplingUMesh::RemoveIdsFromIndexedArrays(&singleVal,&singleVal+1,arr,arrIndx,offsetForRemoval); - case 2: - return MEDCouplingUMesh::RemoveIdsFromIndexedArrays(&multiVal[0],&multiVal[0]+multiVal.size(),arr,arrIndx,offsetForRemoval); - case 4: - return MEDCouplingUMesh::RemoveIdsFromIndexedArrays(daIntTyypp->begin(),daIntTyypp->end(),arr,arrIndx,offsetForRemoval); - default: - throw INTERP_KERNEL::Exception("MEDCouplingUMesh::RemoveIdsFromIndexedArrays : unrecognized type entered, expected list of int, tuple of int or DataArrayInt !"); - } - } - - static PyObject *ExtractFromIndexedArrays(PyObject *li, const DataArrayInt *arrIn, const DataArrayInt *arrIndxIn) throw(INTERP_KERNEL::Exception) - { - DataArrayInt *arrOut=0,*arrIndexOut=0; - int sw; - int singleVal; - std::vector multiVal; - std::pair > slic; - MEDCoupling::DataArrayInt *daIntTyypp=0; - if(!arrIndxIn) - throw INTERP_KERNEL::Exception("MEDCouplingUMesh::ExtractFromIndexedArrays : null pointer as arrIndxIn !"); - convertIntStarOrSliceLikePyObjToCpp(li,arrIndxIn->getNumberOfTuples()-1,sw,singleVal,multiVal,slic,daIntTyypp); - switch(sw) - { - case 1: - { - MEDCouplingUMesh::ExtractFromIndexedArrays(&singleVal,&singleVal+1,arrIn,arrIndxIn,arrOut,arrIndexOut); - break; - } - case 2: - { - MEDCouplingUMesh::ExtractFromIndexedArrays(&multiVal[0],&multiVal[0]+multiVal.size(),arrIn,arrIndxIn,arrOut,arrIndexOut); - break; - } - case 4: - { - MEDCouplingUMesh::ExtractFromIndexedArrays(daIntTyypp->begin(),daIntTyypp->end(),arrIn,arrIndxIn,arrOut,arrIndexOut); - break; - } - default: - throw INTERP_KERNEL::Exception("MEDCouplingUMesh::ExtractFromIndexedArrays : unrecognized type entered, expected list of int, tuple of int or DataArrayInt !"); - } - PyObject *ret=PyTuple_New(2); - PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(arrOut),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(arrIndexOut),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); - return ret; - } - - static PyObject *ExtractFromIndexedArraysSlice(int strt, int stp, int step, const DataArrayInt *arrIn, const DataArrayInt *arrIndxIn) throw(INTERP_KERNEL::Exception) - { - DataArrayInt *arrOut=0,*arrIndexOut=0; - MEDCouplingUMesh::ExtractFromIndexedArraysSlice(strt,stp,step,arrIn,arrIndxIn,arrOut,arrIndexOut); - PyObject *ret=PyTuple_New(2); - PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(arrOut),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(arrIndexOut),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); - return ret; - } - - static PyObject *ExtractFromIndexedArraysSlice(PyObject *slic, const DataArrayInt *arrIn, const DataArrayInt *arrIndxIn) throw(INTERP_KERNEL::Exception) - { - if(!PySlice_Check(slic)) - throw INTERP_KERNEL::Exception("ExtractFromIndexedArraysSlice (wrap) : the first param is not a pyslice !"); - Py_ssize_t strt=2,stp=2,step=2; - if(!arrIndxIn) - throw INTERP_KERNEL::Exception("ExtractFromIndexedArraysSlice (wrap) : last array is null !"); - arrIndxIn->checkAllocated(); - if(arrIndxIn->getNumberOfComponents()!=1) - throw INTERP_KERNEL::Exception("ExtractFromIndexedArraysSlice (wrap) : number of components of last argument must be equal to one !"); - GetIndicesOfSlice(slic,arrIndxIn->getNumberOfTuples(),&strt,&stp,&step,"ExtractFromIndexedArraysSlice (wrap) : Invalid slice regarding nb of elements !"); - DataArrayInt *arrOut=0,*arrIndexOut=0; - MEDCouplingUMesh::ExtractFromIndexedArraysSlice(strt,stp,step,arrIn,arrIndxIn,arrOut,arrIndexOut); - PyObject *ret=PyTuple_New(2); - PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(arrOut),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(arrIndexOut),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); - return ret; - } - - static PyObject *SetPartOfIndexedArrays(PyObject *li, - const DataArrayInt *arrIn, const DataArrayInt *arrIndxIn, - const DataArrayInt *srcArr, const DataArrayInt *srcArrIndex) throw(INTERP_KERNEL::Exception) - { - DataArrayInt *arrOut=0,*arrIndexOut=0; - int sw; - int singleVal; - std::vector multiVal; - std::pair > slic; - MEDCoupling::DataArrayInt *daIntTyypp=0; - if(!arrIndxIn) - throw INTERP_KERNEL::Exception("MEDCouplingUMesh::SetPartOfIndexedArrays : null pointer as arrIndex !"); - convertIntStarOrSliceLikePyObjToCpp(li,arrIndxIn->getNumberOfTuples()-1,sw,singleVal,multiVal,slic,daIntTyypp); - switch(sw) - { - case 1: - { - MEDCouplingUMesh::SetPartOfIndexedArrays(&singleVal,&singleVal+1,arrIn,arrIndxIn,srcArr,srcArrIndex,arrOut,arrIndexOut); - break; - } - case 2: - { - MEDCouplingUMesh::SetPartOfIndexedArrays(&multiVal[0],&multiVal[0]+multiVal.size(),arrIn,arrIndxIn,srcArr,srcArrIndex,arrOut,arrIndexOut); - break; - } - case 4: - { - MEDCouplingUMesh::SetPartOfIndexedArrays(daIntTyypp->begin(),daIntTyypp->end(),arrIn,arrIndxIn,srcArr,srcArrIndex,arrOut,arrIndexOut); - break; - } - default: - throw INTERP_KERNEL::Exception("MEDCouplingUMesh::SetPartOfIndexedArrays : unrecognized type entered, expected list of int, tuple of int or DataArrayInt !"); - } - PyObject *ret=PyTuple_New(2); - PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(arrOut),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); - PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(arrIndexOut),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 )); - return ret; - } - - static void SetPartOfIndexedArraysSameIdx(PyObject *li, DataArrayInt *arrIn, const DataArrayInt *arrIndxIn, - const DataArrayInt *srcArr, const DataArrayInt *srcArrIndex) throw(INTERP_KERNEL::Exception) - { - int sw; - int singleVal; - std::vector multiVal; - std::pair > slic; - MEDCoupling::DataArrayInt *daIntTyypp=0; - if(!arrIndxIn) - throw INTERP_KERNEL::Exception("MEDCouplingUMesh::SetPartOfIndexedArraysSameIdx : null pointer as arrIndex !"); - convertIntStarOrSliceLikePyObjToCpp(li,arrIndxIn->getNumberOfTuples()-1,sw,singleVal,multiVal,slic,daIntTyypp); - switch(sw) - { - case 1: - { - MEDCouplingUMesh::SetPartOfIndexedArraysSameIdx(&singleVal,&singleVal+1,arrIn,arrIndxIn,srcArr,srcArrIndex); - break; - } - case 2: - { - MEDCouplingUMesh::SetPartOfIndexedArraysSameIdx(&multiVal[0],&multiVal[0]+multiVal.size(),arrIn,arrIndxIn,srcArr,srcArrIndex); - break; - } - case 4: - { - MEDCouplingUMesh::SetPartOfIndexedArraysSameIdx(daIntTyypp->begin(),daIntTyypp->end(),arrIn,arrIndxIn,srcArr,srcArrIndex); - break; - } - default: - throw INTERP_KERNEL::Exception("MEDCouplingUMesh::SetPartOfIndexedArraysSameIdx : unrecognized type entered, expected list of int, tuple of int or DataArrayInt !"); - } - } - - PyObject *are2DCellsNotCorrectlyOriented(PyObject *vec, bool polyOnly) const throw(INTERP_KERNEL::Exception) + PyObject *are2DCellsNotCorrectlyOriented(PyObject *vec, bool polyOnly) const { double val; 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) throw(INTERP_KERNEL::Exception) + void orientCorrectly2DCells(PyObject *vec, bool polyOnly) { double val; 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); self->orientCorrectly2DCells(v,polyOnly); } - PyObject *arePolyhedronsNotCorrectlyOriented() const throw(INTERP_KERNEL::Exception) + 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 throw(INTERP_KERNEL::Exception) + PyObject *getFastAveragePlaneOfThis() const { double vec[3]; double pos[3]; @@ -2685,209 +2654,209 @@ namespace MEDCoupling return convertDblArrToPyListOfTuple(vals,3,2); } - static MEDCouplingUMesh *MergeUMeshes(PyObject *li) throw(INTERP_KERNEL::Exception) + static MEDCouplingUMesh *MergeUMeshes(PyObject *li) { std::vector tmp; convertFromPyObjVectorOfObj(li,SWIGTYPE_p_MEDCoupling__MEDCouplingUMesh,"MEDCouplingUMesh",tmp); return MEDCouplingUMesh::MergeUMeshes(tmp); } - PyObject *areCellsIncludedIn(const MEDCouplingUMesh *other, int compType) const throw(INTERP_KERNEL::Exception) + 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 throw(INTERP_KERNEL::Exception) + 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 throw(INTERP_KERNEL::Exception) + 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 throw(INTERP_KERNEL::Exception) + 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 throw(INTERP_KERNEL::Exception) + 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 throw(INTERP_KERNEL::Exception) + 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 throw(INTERP_KERNEL::Exception) + 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 throw(INTERP_KERNEL::Exception) + 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 throw(INTERP_KERNEL::Exception) + 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 throw(INTERP_KERNEL::Exception) + 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 throw(INTERP_KERNEL::Exception) + 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) throw(INTERP_KERNEL::Exception) + 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 throw(INTERP_KERNEL::Exception) + 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 throw(INTERP_KERNEL::Exception) + 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 throw(INTERP_KERNEL::Exception) + 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 throw(INTERP_KERNEL::Exception) + 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(); @@ -2897,41 +2866,41 @@ namespace MEDCoupling return res; } - DataArrayInt *keepCellIdsByType(INTERP_KERNEL::NormalizedCellType type, DataArrayInt *da) const throw(INTERP_KERNEL::Exception) + 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) throw(INTERP_KERNEL::Exception) + 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) throw(INTERP_KERNEL::Exception) + 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; } - PyObject *buildSlice3D(PyObject *origin, PyObject *vec, double eps) const throw(INTERP_KERNEL::Exception) + PyObject *buildSlice3D(PyObject *origin, PyObject *vec, double eps) const { int spaceDim=self->getSpaceDimension(); if(spaceDim!=3) @@ -2940,21 +2909,21 @@ 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; } - PyObject *buildSlice3DSurf(PyObject *origin, PyObject *vec, double eps) const throw(INTERP_KERNEL::Exception) + PyObject *buildSlice3DSurf(PyObject *origin, PyObject *vec, double eps) const { int spaceDim=self->getSpaceDimension(); if(spaceDim!=3) @@ -2963,27 +2932,27 @@ 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; } - MEDCouplingUMesh *clipSingle3DCellByPlane(PyObject *origin, PyObject *vec, double eps) const throw(INTERP_KERNEL::Exception) + MEDCouplingUMesh *clipSingle3DCellByPlane(PyObject *origin, PyObject *vec, double eps) const { double val,val2; 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); @@ -2992,7 +2961,7 @@ namespace MEDCoupling return ret.retn(); } - DataArrayInt *getCellIdsCrossingPlane(PyObject *origin, PyObject *vec, double eps) const throw(INTERP_KERNEL::Exception) + DataArrayIdType *getCellIdsCrossingPlane(PyObject *origin, PyObject *vec, double eps) const { int spaceDim=self->getSpaceDimension(); if(spaceDim!=3) @@ -3001,7 +2970,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); @@ -3009,13 +2978,13 @@ namespace MEDCoupling return self->getCellIdsCrossingPlane(orig,vect,eps); } - void convertToPolyTypes(PyObject *li) throw(INTERP_KERNEL::Exception) + 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) { @@ -3042,11 +3011,11 @@ namespace MEDCoupling } } void convertAllToPoly(); - void convertExtrudedPolyhedra() throw(INTERP_KERNEL::Exception); - bool unPolyze() throw(INTERP_KERNEL::Exception); - void simplifyPolyhedra(double eps) throw(INTERP_KERNEL::Exception); - MEDCouplingUMesh *buildSpreadZonesWithPoly() const throw(INTERP_KERNEL::Exception); - MEDCouplingUMesh *buildExtrudedMesh(const MEDCouplingUMesh *mesh1D, int policy) throw(INTERP_KERNEL::Exception); + void convertExtrudedPolyhedra(); + bool unPolyze(); + void simplifyPolyhedra(double eps); + MEDCouplingUMesh *buildSpreadZonesWithPoly() const; + MEDCouplingUMesh *buildExtrudedMesh(const MEDCouplingUMesh *mesh1D, int policy); }; //== MEDCouplingUMesh End @@ -3056,17 +3025,17 @@ namespace MEDCoupling class MEDCouplingMappedExtrudedMesh : public MEDCoupling::MEDCouplingMesh { public: - static MEDCouplingMappedExtrudedMesh *New(const MEDCouplingUMesh *mesh3D, const MEDCouplingUMesh *mesh2D, int cell2DId) throw(INTERP_KERNEL::Exception); - static MEDCouplingMappedExtrudedMesh *New(const MEDCouplingCMesh *mesh3D) throw(INTERP_KERNEL::Exception); - MEDCouplingUMesh *build3DUnstructuredMesh() const throw(INTERP_KERNEL::Exception); + static MEDCouplingMappedExtrudedMesh *New(const MEDCouplingUMesh *mesh3D, const MEDCouplingUMesh *mesh2D, int cell2DId); + static MEDCouplingMappedExtrudedMesh *New(const MEDCouplingCMesh *mesh3D); + MEDCouplingUMesh *build3DUnstructuredMesh() const; int get2DCellIdForExtrusion() const; %extend { - MEDCouplingMappedExtrudedMesh(const MEDCouplingUMesh *mesh3D, const MEDCouplingUMesh *mesh2D, int cell2DId) throw(INTERP_KERNEL::Exception) + MEDCouplingMappedExtrudedMesh(const MEDCouplingUMesh *mesh3D, const MEDCouplingUMesh *mesh2D, mcIdType cell2DId) { return MEDCouplingMappedExtrudedMesh::New(mesh3D,mesh2D,cell2DId); } - MEDCouplingMappedExtrudedMesh(const MEDCouplingCMesh *mesh3D) throw(INTERP_KERNEL::Exception) + MEDCouplingMappedExtrudedMesh(const MEDCouplingCMesh *mesh3D) { return MEDCouplingMappedExtrudedMesh::New(mesh3D); } @@ -3076,38 +3045,38 @@ namespace MEDCoupling return MEDCouplingMappedExtrudedMesh::New(); } - std::string __str__() const throw(INTERP_KERNEL::Exception) + std::string __str__() const { return self->simpleRepr(); } - std::string __repr__() const throw(INTERP_KERNEL::Exception) + std::string __repr__() const { std::ostringstream oss; self->reprQuickOverview(oss); return oss.str(); } - PyObject *getMesh2D() const throw(INTERP_KERNEL::Exception) + PyObject *getMesh2D() const { MEDCouplingUMesh *ret=self->getMesh2D(); if(ret) ret->incrRef(); return convertMesh(ret, SWIG_POINTER_OWN | 0 ); } - PyObject *getMesh1D() const throw(INTERP_KERNEL::Exception) + PyObject *getMesh1D() const { MEDCouplingUMesh *ret=self->getMesh1D(); if(ret) ret->incrRef(); return convertMesh(ret, SWIG_POINTER_OWN | 0 ); } - PyObject *getMesh3DIds() const throw(INTERP_KERNEL::Exception) + 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 ); } } }; @@ -3117,30 +3086,30 @@ namespace MEDCoupling class MEDCoupling1GTUMesh : public MEDCoupling::MEDCouplingPointSet { public: - static MEDCoupling1GTUMesh *New(const std::string& name, INTERP_KERNEL::NormalizedCellType type) throw(INTERP_KERNEL::Exception); - static MEDCoupling1GTUMesh *New(const MEDCouplingUMesh *m) throw(INTERP_KERNEL::Exception); - INTERP_KERNEL::NormalizedCellType getCellModelEnum() const throw(INTERP_KERNEL::Exception); - int getNodalConnectivityLength() const throw(INTERP_KERNEL::Exception); - virtual void allocateCells(int nbOfCells=0) throw(INTERP_KERNEL::Exception); - virtual void checkConsistencyOfConnectivity() const throw(INTERP_KERNEL::Exception); + static MEDCoupling1GTUMesh *New(const std::string& name, INTERP_KERNEL::NormalizedCellType type); + static MEDCoupling1GTUMesh *New(const MEDCouplingUMesh *m); + INTERP_KERNEL::NormalizedCellType getCellModelEnum() const; + int getNodalConnectivityLength() const; + virtual void allocateCells(int nbOfCells=0); + virtual void checkConsistencyOfConnectivity() const; %extend { - virtual void insertNextCell(PyObject *li) throw(INTERP_KERNEL::Exception) + 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 throw(INTERP_KERNEL::Exception) + virtual DataArrayIdType *getNodalConnectivity() const { - DataArrayInt *ret=self->getNodalConnectivity(); + DataArrayIdType *ret=self->getNodalConnectivity(); if(ret) ret->incrRef(); return ret; } - static MEDCouplingUMesh *AggregateOnSameCoordsToUMesh(PyObject *li) throw(INTERP_KERNEL::Exception) + static MEDCouplingUMesh *AggregateOnSameCoordsToUMesh(PyObject *li) { std::vector< const MEDCoupling1GTUMesh *> parts; convertFromPyObjVectorOfObj(li,SWIGTYPE_p_MEDCoupling__MEDCoupling1GTUMesh,"MEDCoupling1GTUMesh",parts); @@ -3154,15 +3123,15 @@ namespace MEDCoupling class MEDCoupling1SGTUMesh : public MEDCoupling::MEDCoupling1GTUMesh { public: - static MEDCoupling1SGTUMesh *New(const std::string& name, INTERP_KERNEL::NormalizedCellType type) throw(INTERP_KERNEL::Exception); - static MEDCoupling1SGTUMesh *New(const MEDCouplingUMesh *m) throw(INTERP_KERNEL::Exception); - void setNodalConnectivity(DataArrayInt *nodalConn) throw(INTERP_KERNEL::Exception); - int getNumberOfNodesPerCell() const throw(INTERP_KERNEL::Exception); - static MEDCoupling1SGTUMesh *Merge1SGTUMeshes(const MEDCoupling1SGTUMesh *mesh1, const MEDCoupling1SGTUMesh *mesh2) throw(INTERP_KERNEL::Exception); - MEDCoupling1SGTUMesh *buildSetInstanceFromThis(int spaceDim) const throw(INTERP_KERNEL::Exception); - MEDCoupling1GTUMesh *computeDualMesh() const throw(INTERP_KERNEL::Exception); - MEDCoupling1SGTUMesh *explodeEachHexa8To6Quad4() const throw(INTERP_KERNEL::Exception); - DataArrayInt *sortHexa8EachOther() throw(INTERP_KERNEL::Exception); + static MEDCoupling1SGTUMesh *New(const std::string& name, INTERP_KERNEL::NormalizedCellType type); + static MEDCoupling1SGTUMesh *New(const MEDCouplingUMesh *m); + 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; + DataArrayIdType *sortHexa8EachOther(); %extend { MEDCoupling1SGTUMesh() @@ -3170,47 +3139,47 @@ namespace MEDCoupling return MEDCoupling1SGTUMesh::New(); } - MEDCoupling1SGTUMesh(const std::string& name, INTERP_KERNEL::NormalizedCellType type) throw(INTERP_KERNEL::Exception) + MEDCoupling1SGTUMesh(const std::string& name, INTERP_KERNEL::NormalizedCellType type) { return MEDCoupling1SGTUMesh::New(name,type); } - MEDCoupling1SGTUMesh(const MEDCouplingUMesh *m) throw(INTERP_KERNEL::Exception) + MEDCoupling1SGTUMesh(const MEDCouplingUMesh *m) { return MEDCoupling1SGTUMesh::New(m); } - std::string __str__() const throw(INTERP_KERNEL::Exception) + std::string __str__() const { return self->simpleRepr(); } - std::string __repr__() const throw(INTERP_KERNEL::Exception) + std::string __repr__() const { std::ostringstream oss; self->reprQuickOverview(oss); return oss.str(); } - PyObject *structurizeMe(double eps=1e-12) const throw(INTERP_KERNEL::Exception) + 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; } - static MEDCoupling1SGTUMesh *Merge1SGTUMeshes(PyObject *li) throw(INTERP_KERNEL::Exception) + static MEDCoupling1SGTUMesh *Merge1SGTUMeshes(PyObject *li) { std::vector tmp; convertFromPyObjVectorOfObj(li,SWIGTYPE_p_MEDCoupling__MEDCoupling1SGTUMesh,"MEDCoupling1SGTUMesh",tmp); return MEDCoupling1SGTUMesh::Merge1SGTUMeshes(tmp); } - static MEDCoupling1SGTUMesh *Merge1SGTUMeshesOnSameCoords(PyObject *li) throw(INTERP_KERNEL::Exception) + static MEDCoupling1SGTUMesh *Merge1SGTUMeshesOnSameCoords(PyObject *li) { std::vector tmp; convertFromPyObjVectorOfObj(li,SWIGTYPE_p_MEDCoupling__MEDCoupling1SGTUMesh,"MEDCoupling1SGTUMesh",tmp); @@ -3226,60 +3195,60 @@ namespace MEDCoupling class MEDCoupling1DGTUMesh : public MEDCoupling::MEDCoupling1GTUMesh { public: - static MEDCoupling1DGTUMesh *New(const std::string& name, INTERP_KERNEL::NormalizedCellType type) throw(INTERP_KERNEL::Exception); - static MEDCoupling1DGTUMesh *New(const MEDCouplingUMesh *m) throw(INTERP_KERNEL::Exception); - void setNodalConnectivity(DataArrayInt *nodalConn, DataArrayInt *nodalConnIndex) throw(INTERP_KERNEL::Exception); - MEDCoupling1DGTUMesh *buildSetInstanceFromThis(int spaceDim) const throw(INTERP_KERNEL::Exception); - bool isPacked() const throw(INTERP_KERNEL::Exception); + static MEDCoupling1DGTUMesh *New(const std::string& name, INTERP_KERNEL::NormalizedCellType type); + static MEDCoupling1DGTUMesh *New(const MEDCouplingUMesh *m); + void setNodalConnectivity(DataArrayIdType *nodalConn, DataArrayIdType *nodalConnIndex); + MEDCoupling1DGTUMesh *buildSetInstanceFromThis(int spaceDim) const; + bool isPacked() const; %extend { MEDCoupling1DGTUMesh() { return MEDCoupling1DGTUMesh::New(); } - MEDCoupling1DGTUMesh(const std::string& name, INTERP_KERNEL::NormalizedCellType type) throw(INTERP_KERNEL::Exception) + MEDCoupling1DGTUMesh(const std::string& name, INTERP_KERNEL::NormalizedCellType type) { return MEDCoupling1DGTUMesh::New(name,type); } - MEDCoupling1DGTUMesh(const MEDCouplingUMesh *m) throw(INTERP_KERNEL::Exception) + MEDCoupling1DGTUMesh(const MEDCouplingUMesh *m) { return MEDCoupling1DGTUMesh::New(m); } - std::string __str__() const throw(INTERP_KERNEL::Exception) + std::string __str__() const { return self->simpleRepr(); } - std::string __repr__() const throw(INTERP_KERNEL::Exception) + std::string __repr__() const { std::ostringstream oss; self->reprQuickOverview(oss); return oss.str(); } - DataArrayInt *getNodalConnectivityIndex() const throw(INTERP_KERNEL::Exception) + DataArrayIdType *getNodalConnectivityIndex() const { - DataArrayInt *ret=self->getNodalConnectivityIndex(); + DataArrayIdType *ret=self->getNodalConnectivityIndex(); if(ret) ret->incrRef(); return ret; } - PyObject *retrievePackedNodalConnectivity() const throw(INTERP_KERNEL::Exception) + 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; } - PyObject *copyWithNodalConnectivityPacked() const throw(INTERP_KERNEL::Exception) + PyObject *copyWithNodalConnectivityPacked() const { bool ret1; MEDCoupling1DGTUMesh *ret0=self->copyWithNodalConnectivityPacked(ret1); @@ -3290,24 +3259,24 @@ namespace MEDCoupling return ret; } - static MEDCoupling1DGTUMesh *Merge1DGTUMeshes(PyObject *li) throw(INTERP_KERNEL::Exception) + static MEDCoupling1DGTUMesh *Merge1DGTUMeshes(PyObject *li) { std::vector tmp; convertFromPyObjVectorOfObj(li,SWIGTYPE_p_MEDCoupling__MEDCoupling1DGTUMesh,"MEDCoupling1DGTUMesh",tmp); return MEDCoupling1DGTUMesh::Merge1DGTUMeshes(tmp); } - static MEDCoupling1DGTUMesh *Merge1DGTUMeshesOnSameCoords(PyObject *li) throw(INTERP_KERNEL::Exception) + static MEDCoupling1DGTUMesh *Merge1DGTUMeshesOnSameCoords(PyObject *li) { std::vector tmp; convertFromPyObjVectorOfObj(li,SWIGTYPE_p_MEDCoupling__MEDCoupling1DGTUMesh,"MEDCoupling1DGTUMesh",tmp); return MEDCoupling1DGTUMesh::Merge1DGTUMeshesOnSameCoords(tmp); } - static DataArrayInt *AggregateNodalConnAndShiftNodeIds(PyObject *li, const std::vector& offsetInNodeIdsPerElt) throw(INTERP_KERNEL::Exception) + 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); } } @@ -3318,32 +3287,32 @@ namespace MEDCoupling class MEDCouplingStructuredMesh : public MEDCoupling::MEDCouplingMesh { public: - int getCellIdFromPos(int i, int j, int k) const throw(INTERP_KERNEL::Exception); - int getNodeIdFromPos(int i, int j, int k) const throw(INTERP_KERNEL::Exception); - int getNumberOfCellsOfSubLevelMesh() const throw(INTERP_KERNEL::Exception); - int getSpaceDimensionOnNodeStruct() const throw(INTERP_KERNEL::Exception); - double computeSquareness() const throw(INTERP_KERNEL::Exception); - virtual std::vector getNodeGridStructure() const throw(INTERP_KERNEL::Exception); - std::vector getCellGridStructure() const throw(INTERP_KERNEL::Exception); - MEDCoupling1SGTUMesh *build1SGTUnstructured() const throw(INTERP_KERNEL::Exception); - std::vector getLocationFromCellId(int cellId) const throw(INTERP_KERNEL::Exception); - std::vector getLocationFromNodeId(int cellId) const throw(INTERP_KERNEL::Exception); - static INTERP_KERNEL::NormalizedCellType GetGeoTypeGivenMeshDimension(int meshDim) throw(INTERP_KERNEL::Exception); - MEDCoupling1SGTUMesh *build1SGTSubLevelMesh() const throw(INTERP_KERNEL::Exception); - static int DeduceNumberOfGivenStructure(const std::vector& st) throw(INTERP_KERNEL::Exception); - static DataArrayInt *ComputeCornersGhost(const std::vector& st, int ghostLev) throw(INTERP_KERNEL::Exception); - static std::vector GetSplitVectFromStruct(const std::vector& strct) throw(INTERP_KERNEL::Exception); + 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; + MEDCoupling1SGTUMesh *build1SGTUnstructured() const; + std::vector getLocationFromCellId(mcIdType cellId) const; + std::vector getLocationFromNodeId(mcIdType cellId) const; + static INTERP_KERNEL::NormalizedCellType GetGeoTypeGivenMeshDimension(int meshDim); + MEDCoupling1SGTUMesh *build1SGTSubLevelMesh() const; + 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 throw(INTERP_KERNEL::Exception) + 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) throw(INTERP_KERNEL::Exception) + 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) throw(INTERP_KERNEL::Exception) + 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) throw(INTERP_KERNEL::Exception) + 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) throw(INTERP_KERNEL::Exception) + 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)); @@ -3399,53 +3368,53 @@ namespace MEDCoupling return ret; } - static DataArrayDouble *ExtractFieldOfDoubleFrom(const std::vector& st, const DataArrayDouble *fieldOfDbl, PyObject *partCompactFormat) throw(INTERP_KERNEL::Exception) + 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) throw(INTERP_KERNEL::Exception) + 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) throw(INTERP_KERNEL::Exception) + 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) throw(INTERP_KERNEL::Exception) + 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) throw(INTERP_KERNEL::Exception) + 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) throw(INTERP_KERNEL::Exception) + 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) throw(INTERP_KERNEL::Exception) + 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); } - static PyObject *IsPartStructured(PyObject *li, PyObject *st) throw(INTERP_KERNEL::Exception) + 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); @@ -3508,9 +3477,9 @@ namespace MEDCoupling return ret; } - static PyObject *ChangeReferenceFromGlobalOfCompactFrmt(PyObject *bigInAbs, PyObject *partOfBigInAbs, bool check=true) throw(INTERP_KERNEL::Exception) + 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); @@ -3525,11 +3494,11 @@ namespace MEDCoupling return retPy; } - static PyObject *TranslateCompactFrmt(PyObject *part, const std::vector& translation) throw(INTERP_KERNEL::Exception) + 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) throw(INTERP_KERNEL::Exception) + 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); } - static PyObject *ChangeReferenceToGlobalOfCompactFrmt(PyObject *bigInAbs, PyObject *partOfBigRelativeToBig, bool check=true) throw(INTERP_KERNEL::Exception) + 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); @@ -3575,33 +3544,33 @@ namespace MEDCoupling class MEDCouplingCMesh : public MEDCoupling::MEDCouplingStructuredMesh { public: - static MEDCouplingCMesh *New() throw(INTERP_KERNEL::Exception); - static MEDCouplingCMesh *New(const std::string& meshName) throw(INTERP_KERNEL::Exception); + static MEDCouplingCMesh *New(); + static MEDCouplingCMesh *New(const std::string& meshName); void setCoords(const DataArrayDouble *coordsX, const DataArrayDouble *coordsY=0, - const DataArrayDouble *coordsZ=0) throw(INTERP_KERNEL::Exception); - void setCoordsAt(int i, const DataArrayDouble *arr) throw(INTERP_KERNEL::Exception); - MEDCouplingCurveLinearMesh *buildCurveLinear() const throw(INTERP_KERNEL::Exception); + const DataArrayDouble *coordsZ=0); + void setCoordsAt(int i, const DataArrayDouble *arr); + MEDCouplingCurveLinearMesh *buildCurveLinear() const; %extend { - MEDCouplingCMesh() throw(INTERP_KERNEL::Exception) + MEDCouplingCMesh() { return MEDCouplingCMesh::New(); } - MEDCouplingCMesh(const std::string& meshName) throw(INTERP_KERNEL::Exception) + MEDCouplingCMesh(const std::string& meshName) { return MEDCouplingCMesh::New(meshName); } - std::string __str__() const throw(INTERP_KERNEL::Exception) + std::string __str__() const { return self->simpleRepr(); } - std::string __repr__() const throw(INTERP_KERNEL::Exception) + std::string __repr__() const { std::ostringstream oss; self->reprQuickOverview(oss); return oss.str(); } - DataArrayDouble *getCoordsAt(int i) throw(INTERP_KERNEL::Exception) + DataArrayDouble *getCoordsAt(int i) { DataArrayDouble *ret=self->getCoordsAt(i); if(ret) @@ -3618,40 +3587,40 @@ namespace MEDCoupling class MEDCouplingCurveLinearMesh : public MEDCoupling::MEDCouplingStructuredMesh { public: - static MEDCouplingCurveLinearMesh *New() throw(INTERP_KERNEL::Exception); - static MEDCouplingCurveLinearMesh *New(const std::string& meshName) throw(INTERP_KERNEL::Exception); - void setCoords(const DataArrayDouble *coords) throw(INTERP_KERNEL::Exception); + static MEDCouplingCurveLinearMesh *New(); + static MEDCouplingCurveLinearMesh *New(const std::string& meshName); + void setCoords(const DataArrayDouble *coords); %extend { - MEDCouplingCurveLinearMesh() throw(INTERP_KERNEL::Exception) + MEDCouplingCurveLinearMesh() { return MEDCouplingCurveLinearMesh::New(); } - MEDCouplingCurveLinearMesh(const std::string& meshName) throw(INTERP_KERNEL::Exception) + MEDCouplingCurveLinearMesh(const std::string& meshName) { return MEDCouplingCurveLinearMesh::New(meshName); } - std::string __str__() const throw(INTERP_KERNEL::Exception) + std::string __str__() const { return self->simpleRepr(); } - std::string __repr__() const throw(INTERP_KERNEL::Exception) + std::string __repr__() const { std::ostringstream oss; self->reprQuickOverview(oss); return oss.str(); } - DataArrayDouble *getCoords() throw(INTERP_KERNEL::Exception) + DataArrayDouble *getCoords() { DataArrayDouble *ret=self->getCoords(); if(ret) ret->incrRef(); return ret; } - void setNodeGridStructure(PyObject *gridStruct) throw(INTERP_KERNEL::Exception) + 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); } } @@ -3664,121 +3633,117 @@ namespace MEDCoupling class MEDCouplingIMesh : public MEDCoupling::MEDCouplingStructuredMesh { public: - static MEDCouplingIMesh *New() throw(INTERP_KERNEL::Exception); + static MEDCouplingIMesh *New(); // - void setSpaceDimension(int spaceDim) throw(INTERP_KERNEL::Exception); - std::vector getNodeStruct() const throw(INTERP_KERNEL::Exception); - std::vector getOrigin() const throw(INTERP_KERNEL::Exception); - std::vector getDXYZ() const throw(INTERP_KERNEL::Exception); - void setAxisUnit(const std::string& unitName) throw(INTERP_KERNEL::Exception); - std::string getAxisUnit() const throw(INTERP_KERNEL::Exception); - double getMeasureOfAnyCell() const throw(INTERP_KERNEL::Exception); - MEDCouplingCMesh *convertToCartesian() const throw(INTERP_KERNEL::Exception); - void refineWithFactor(const std::vector& factors) throw(INTERP_KERNEL::Exception); - MEDCouplingIMesh *asSingleCell() const throw(INTERP_KERNEL::Exception); - MEDCouplingIMesh *buildWithGhost(int ghostLev) const throw(INTERP_KERNEL::Exception); + void setSpaceDimension(int spaceDim); + 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); + MEDCouplingIMesh *asSingleCell() const; + MEDCouplingIMesh *buildWithGhost(mcIdType ghostLev) const; %extend { MEDCouplingIMesh() { return MEDCouplingIMesh::New(); } - static MEDCouplingIMesh *New(const std::string& meshName, int spaceDim, PyObject *nodeStrct, PyObject *origin, PyObject *dxyz) throw(INTERP_KERNEL::Exception) + static MEDCouplingIMesh *New(const std::string& meshName, int spaceDim, PyObject *nodeStrct, PyObject *origin, PyObject *dxyz) { 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); // return MEDCouplingIMesh::New(meshName,spaceDim,nodeStrctPtr,nodeStrctPtr+sz,originPtr,originPtr+sz1,dxyzPtr,dxyzPtr+sz2); } - MEDCouplingIMesh(const std::string& meshName, int spaceDim, PyObject *nodeStrct, PyObject *origin, PyObject *dxyz) throw(INTERP_KERNEL::Exception) + MEDCouplingIMesh(const std::string& meshName, int spaceDim, PyObject *nodeStrct, PyObject *origin, PyObject *dxyz) { return MEDCoupling_MEDCouplingIMesh_New__SWIG_1(meshName,spaceDim,nodeStrct,origin,dxyz); } - void setNodeStruct(PyObject *nodeStrct) throw(INTERP_KERNEL::Exception) + 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); } - void setOrigin(PyObject *origin) throw(INTERP_KERNEL::Exception) + void setOrigin(PyObject *origin) { 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); } - void setDXYZ(PyObject *dxyz) throw(INTERP_KERNEL::Exception) + void setDXYZ(PyObject *dxyz) { 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) throw(INTERP_KERNEL::Exception) + 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) throw(INTERP_KERNEL::Exception) + 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) throw(INTERP_KERNEL::Exception) + 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) throw(INTERP_KERNEL::Exception) + 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) throw(INTERP_KERNEL::Exception) + 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); } - std::string __str__() const throw(INTERP_KERNEL::Exception) + std::string __str__() const { return self->simpleRepr(); } - std::string __repr__() const throw(INTERP_KERNEL::Exception) + std::string __repr__() const { std::ostringstream oss; self->reprQuickOverview(oss); @@ -3796,32 +3761,34 @@ namespace MEDCoupling class MEDCouplingField : public MEDCoupling::RefCountObject, public MEDCoupling::TimeLabel { public: - virtual void checkConsistencyLight() const throw(INTERP_KERNEL::Exception); - virtual bool areCompatibleForMerge(const MEDCouplingField *other) const throw(INTERP_KERNEL::Exception); - virtual void copyTinyStringsFrom(const MEDCouplingField *other) throw(INTERP_KERNEL::Exception); - void setMesh(const MEDCoupling::MEDCouplingMesh *mesh) throw(INTERP_KERNEL::Exception); - void setName(const char *name) throw(INTERP_KERNEL::Exception); - std::string getDescription() const throw(INTERP_KERNEL::Exception); - void setDescription(const char *desc) throw(INTERP_KERNEL::Exception); - std::string getName() const throw(INTERP_KERNEL::Exception); - TypeOfField getTypeOfField() const throw(INTERP_KERNEL::Exception); - NatureOfField getNature() const throw(INTERP_KERNEL::Exception); - virtual void setNature(NatureOfField nat) throw(INTERP_KERNEL::Exception); - DataArrayDouble *getLocalizationOfDiscr() const throw(INTERP_KERNEL::Exception); - MEDCouplingFieldDouble *buildMeasureField(bool isAbs) const throw(INTERP_KERNEL::Exception); - int getNumberOfTuplesExpected() const throw(INTERP_KERNEL::Exception); - int getNumberOfMeshPlacesExpected() const throw(INTERP_KERNEL::Exception); + 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); + std::string getDescription() const; + void setDescription(const char *desc); + std::string getName() const; + TypeOfField getTypeOfField() const; + NatureOfField getNature() const; + virtual void setNature(NatureOfField nat); + DataArrayDouble *getLocalizationOfDiscr() const; + MEDCouplingFieldDouble *buildMeasureField(bool isAbs) 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) throw(INTERP_KERNEL::Exception); - void clearGaussLocalizations() throw(INTERP_KERNEL::Exception); - MEDCouplingGaussLocalization& getGaussLocalization(int locId) throw(INTERP_KERNEL::Exception); - int getNbOfGaussLocalization() const throw(INTERP_KERNEL::Exception); - int getGaussLocalizationIdOfOneCell(int cellId) const throw(INTERP_KERNEL::Exception); - const MEDCouplingGaussLocalization& getGaussLocalization(int locId) const throw(INTERP_KERNEL::Exception); - int getGaussLocalizationIdOfOneType(INTERP_KERNEL::NormalizedCellType type) const throw(INTERP_KERNEL::Exception); + const std::vector& gsCoo, const std::vector& wg); + void clearGaussLocalizations(); + MEDCouplingGaussLocalization& getGaussLocalization(int locId); + mcIdType getNbOfGaussLocalization() const; + mcIdType getGaussLocalizationIdOfOneCell(mcIdType cellId) const; + const MEDCouplingGaussLocalization& getGaussLocalization(int locId) const; + mcIdType getGaussLocalizationIdOfOneType(INTERP_KERNEL::NormalizedCellType type) const; void setDiscretization(MEDCouplingFieldDiscretization *newDisc); %extend { - PyObject *getMesh() const throw(INTERP_KERNEL::Exception) + PyObject *getMesh() const { MEDCouplingMesh *ret1=const_cast(self->getMesh()); if(ret1) @@ -3829,7 +3796,7 @@ namespace MEDCoupling return convertMesh(ret1,SWIG_POINTER_OWN | 0 ); } - PyObject *getDiscretization() throw(INTERP_KERNEL::Exception) + PyObject *getDiscretization() { MEDCouplingFieldDiscretization *ret=self->getDiscretization(); if(ret) @@ -3837,47 +3804,47 @@ namespace MEDCoupling return convertFieldDiscretization(ret,SWIG_POINTER_OWN | 0 ); } - PyObject *getGaussLocalizationIdsOfOneType(INTERP_KERNEL::NormalizedCellType type) const throw(INTERP_KERNEL::Exception) + 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 throw(INTERP_KERNEL::Exception) + 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 throw(INTERP_KERNEL::Exception) + 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)); @@ -3886,51 +3853,51 @@ 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); } void setGaussLocalizationOnCells(PyObject *li, const std::vector& refCoo, - const std::vector& gsCoo, const std::vector& wg) throw(INTERP_KERNEL::Exception) + 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); } } - PyObject *getCellIdsHavingGaussLocalization(int locId) const throw(INTERP_KERNEL::Exception) + 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 throw(INTERP_KERNEL::Exception) + 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); } } @@ -3939,49 +3906,55 @@ namespace MEDCoupling class MEDCouplingFieldTemplate : public MEDCoupling::MEDCouplingField { public: - static MEDCouplingFieldTemplate *New(const MEDCouplingFieldDouble& f) throw(INTERP_KERNEL::Exception); - static MEDCouplingFieldTemplate *New(const MEDCouplingFieldFloat& f) throw(INTERP_KERNEL::Exception); - static MEDCouplingFieldTemplate *New(const MEDCouplingFieldInt& f) throw(INTERP_KERNEL::Exception); + static MEDCouplingFieldTemplate *New(const MEDCouplingFieldDouble& f); + static MEDCouplingFieldTemplate *New(const MEDCouplingFieldFloat& f); + static MEDCouplingFieldTemplate *New(const MEDCouplingFieldInt32& f); + static MEDCouplingFieldTemplate *New(const MEDCouplingFieldInt64& f); static MEDCouplingFieldTemplate *New(TypeOfField type); - std::string simpleRepr() const throw(INTERP_KERNEL::Exception); - std::string advancedRepr() const throw(INTERP_KERNEL::Exception); - bool isEqual(const MEDCouplingFieldTemplate *other, double meshPrec) const throw(INTERP_KERNEL::Exception); - bool isEqualWithoutConsideringStr(const MEDCouplingFieldTemplate *other, double meshPrec) const throw(INTERP_KERNEL::Exception); + std::string simpleRepr() const; + std::string advancedRepr() const; + bool isEqual(const MEDCouplingFieldTemplate *other, double meshPrec) const; + bool isEqualWithoutConsideringStr(const MEDCouplingFieldTemplate *other, double meshPrec) const; %extend { - MEDCouplingFieldTemplate(const MEDCouplingFieldDouble& f) throw(INTERP_KERNEL::Exception) + MEDCouplingFieldTemplate(const MEDCouplingFieldDouble& f) { return MEDCouplingFieldTemplate::New(f); } - MEDCouplingFieldTemplate(const MEDCouplingFieldFloat& f) throw(INTERP_KERNEL::Exception) + MEDCouplingFieldTemplate(const MEDCouplingFieldFloat& f) { return MEDCouplingFieldTemplate::New(f); } - MEDCouplingFieldTemplate(const MEDCouplingFieldInt& f) throw(INTERP_KERNEL::Exception) + MEDCouplingFieldTemplate(const MEDCouplingFieldInt32& f) + { + return MEDCouplingFieldTemplate::New(f); + } + + MEDCouplingFieldTemplate(const MEDCouplingFieldInt64& f) { return MEDCouplingFieldTemplate::New(f); } - MEDCouplingFieldTemplate(TypeOfField type) throw(INTERP_KERNEL::Exception) + MEDCouplingFieldTemplate(TypeOfField type) { return MEDCouplingFieldTemplate::New(type); } - std::string __str__() const throw(INTERP_KERNEL::Exception) + std::string __str__() const { return self->simpleRepr(); } - std::string __repr__() const throw(INTERP_KERNEL::Exception) + std::string __repr__() const { std::ostringstream oss; self->reprQuickOverview(oss); return oss.str(); } - PyObject *isEqualIfNotWhy(const MEDCouplingFieldTemplate *other, double meshPrec) const throw(INTERP_KERNEL::Exception) + PyObject *isEqualIfNotWhy(const MEDCouplingFieldTemplate *other, double meshPrec) const { std::string ret1; bool ret0=self->isEqualIfNotWhy(other,meshPrec,ret1); @@ -3999,7 +3972,7 @@ namespace MEDCoupling class MEDCouplingFieldT : public MEDCoupling::MEDCouplingField { public: - TypeOfTimeDiscretization getTimeDiscretization() const throw(INTERP_KERNEL::Exception); + TypeOfTimeDiscretization getTimeDiscretization() const; protected: MEDCouplingFieldT(); ~MEDCouplingFieldT(); @@ -4009,7 +3982,8 @@ namespace MEDCoupling %template(MEDCouplingFieldTfloat) MEDCoupling::MEDCouplingFieldT; %template(MEDCouplingFieldTint) MEDCoupling::MEDCouplingFieldT; - class MEDCouplingFieldInt; + class MEDCouplingFieldInt32; + class MEDCouplingFieldInt64; class MEDCouplingFieldFloat; class MEDCouplingFieldDouble : public MEDCouplingFieldT @@ -4017,102 +3991,102 @@ namespace MEDCoupling public: static MEDCouplingFieldDouble *New(TypeOfField type, TypeOfTimeDiscretization td=ONE_TIME); static MEDCouplingFieldDouble *New(const MEDCouplingFieldTemplate& ft, TypeOfTimeDiscretization td=ONE_TIME); - bool isEqual(const MEDCouplingFieldDouble *other, double meshPrec, double valsPrec) const throw(INTERP_KERNEL::Exception); - bool isEqualWithoutConsideringStr(const MEDCouplingFieldDouble *other, double meshPrec, double valsPrec) const throw(INTERP_KERNEL::Exception); + bool isEqual(const MEDCouplingFieldDouble *other, double meshPrec, double valsPrec) const; + bool isEqualWithoutConsideringStr(const MEDCouplingFieldDouble *other, double meshPrec, double valsPrec) const; void setTimeUnit(const std::string& unit); std::string getTimeUnit() const; - void synchronizeTimeWithSupport() throw(INTERP_KERNEL::Exception); - void copyTinyAttrFrom(const MEDCouplingFieldDouble *other) throw(INTERP_KERNEL::Exception); - void copyAllTinyAttrFrom(const MEDCouplingFieldDouble *other) throw(INTERP_KERNEL::Exception); - std::string simpleRepr() const throw(INTERP_KERNEL::Exception); - std::string advancedRepr() const throw(INTERP_KERNEL::Exception); - std::string writeVTK(const std::string& fileName, bool isBinary=true) const throw(INTERP_KERNEL::Exception); - MEDCouplingFieldInt *convertToIntField() const throw(INTERP_KERNEL::Exception); - MEDCouplingFieldFloat *convertToFloatField() const throw(INTERP_KERNEL::Exception); + void synchronizeTimeWithSupport(); + void copyTinyAttrFrom(const MEDCouplingFieldDouble *other); + void copyAllTinyAttrFrom(const MEDCouplingFieldDouble *other); + std::string simpleRepr() const; + std::string advancedRepr() const; + std::string writeVTK(const std::string& fileName, bool isBinary=true) const; + MEDCouplingFieldInt32 *convertToIntField() const; + MEDCouplingFieldFloat *convertToFloatField() const; MEDCouplingFieldDouble *clone(bool recDeepCpy) const; MEDCouplingFieldDouble *cloneWithMesh(bool recDeepCpy) const; MEDCouplingFieldDouble *deepCopy() const; - MEDCouplingFieldDouble *buildNewTimeReprFromThis(TypeOfTimeDiscretization td, bool deepCopy) const throw(INTERP_KERNEL::Exception); - MEDCouplingFieldDouble *nodeToCellDiscretization() const throw(INTERP_KERNEL::Exception); - MEDCouplingFieldDouble *cellToNodeDiscretization() const throw(INTERP_KERNEL::Exception); - double getIJ(int tupleId, int compoId) const throw(INTERP_KERNEL::Exception); - double getIJK(int cellId, int nodeIdInCell, int compoId) const throw(INTERP_KERNEL::Exception); - void synchronizeTimeWithMesh() throw(INTERP_KERNEL::Exception); - void setArray(DataArrayDouble *array) throw(INTERP_KERNEL::Exception); - void setEndArray(DataArrayDouble *array) throw(INTERP_KERNEL::Exception); - void setTime(double val, int iteration, int order) throw(INTERP_KERNEL::Exception); - void setStartTime(double val, int iteration, int order) throw(INTERP_KERNEL::Exception); - void setEndTime(double val, int iteration, int order) throw(INTERP_KERNEL::Exception); - void applyLin(double a, double b, int compoId) throw(INTERP_KERNEL::Exception); - void applyLin(double a, double b) throw(INTERP_KERNEL::Exception); - int getNumberOfComponents() const throw(INTERP_KERNEL::Exception); - int getNumberOfTuples() const throw(INTERP_KERNEL::Exception); - int getNumberOfValues() const throw(INTERP_KERNEL::Exception); - void setTimeTolerance(double val) throw(INTERP_KERNEL::Exception); - double getTimeTolerance() const throw(INTERP_KERNEL::Exception); - void setIteration(int it) throw(INTERP_KERNEL::Exception); - void setEndIteration(int it) throw(INTERP_KERNEL::Exception); - void setOrder(int order) throw(INTERP_KERNEL::Exception); - void setEndOrder(int order) throw(INTERP_KERNEL::Exception); - void setTimeValue(double val) throw(INTERP_KERNEL::Exception); - void setEndTimeValue(double val) throw(INTERP_KERNEL::Exception); - void changeUnderlyingMesh(const MEDCouplingMesh *other, int levOfCheck, double precOnMesh, double eps=1e-15) throw(INTERP_KERNEL::Exception); - void substractInPlaceDM(const MEDCouplingFieldDouble *f, int levOfCheck, double precOnMesh, double eps=1e-15) throw(INTERP_KERNEL::Exception); - bool mergeNodes(double eps, double epsOnVals=1e-15) throw(INTERP_KERNEL::Exception); - bool mergeNodesCenter(double eps, double epsOnVals=1e-15) throw(INTERP_KERNEL::Exception); - bool zipCoords(double epsOnVals=1e-15) throw(INTERP_KERNEL::Exception); - bool zipConnectivity(int compType,double epsOnVals=1e-15) throw(INTERP_KERNEL::Exception); - bool simplexize(int policy) throw(INTERP_KERNEL::Exception); - MEDCouplingFieldDouble *doublyContractedProduct() const throw(INTERP_KERNEL::Exception); - MEDCouplingFieldDouble *determinant() const throw(INTERP_KERNEL::Exception); - MEDCouplingFieldDouble *eigenValues() const throw(INTERP_KERNEL::Exception); - MEDCouplingFieldDouble *eigenVectors() const throw(INTERP_KERNEL::Exception); - MEDCouplingFieldDouble *inverse() const throw(INTERP_KERNEL::Exception); - MEDCouplingFieldDouble *trace() const throw(INTERP_KERNEL::Exception); - MEDCouplingFieldDouble *deviator() const throw(INTERP_KERNEL::Exception); - MEDCouplingFieldDouble *magnitude() const throw(INTERP_KERNEL::Exception); - MEDCouplingFieldDouble *maxPerTuple() const throw(INTERP_KERNEL::Exception); - void changeNbOfComponents(int newNbOfComp, double dftValue=0.) throw(INTERP_KERNEL::Exception); - void sortPerTuple(bool asc) throw(INTERP_KERNEL::Exception); - MEDCouplingFieldDouble &operator=(double value) throw(INTERP_KERNEL::Exception); - void fillFromAnalytic(int nbOfComp, const std::string& func) throw(INTERP_KERNEL::Exception); - void fillFromAnalyticCompo(int nbOfComp, const std::string& func) throw(INTERP_KERNEL::Exception); - void fillFromAnalyticNamedCompo(int nbOfComp, const std::vector& varsOrder, const std::string& func) throw(INTERP_KERNEL::Exception); - void applyFunc(int nbOfComp, const std::string& func) throw(INTERP_KERNEL::Exception); - void applyFuncCompo(int nbOfComp, const std::string& func) throw(INTERP_KERNEL::Exception); - void applyFuncNamedCompo(int nbOfComp, const std::vector& varsOrder, const std::string& func) throw(INTERP_KERNEL::Exception); - void applyFunc(int nbOfComp, double val) throw(INTERP_KERNEL::Exception); - void applyFunc(const std::string& func) throw(INTERP_KERNEL::Exception); - void applyFuncFast32(const std::string& func) throw(INTERP_KERNEL::Exception); - void applyFuncFast64(const std::string& func) throw(INTERP_KERNEL::Exception); - double accumulate(int compId) const throw(INTERP_KERNEL::Exception); - double getMaxValue() const throw(INTERP_KERNEL::Exception); - double getMinValue() const throw(INTERP_KERNEL::Exception); - double getAverageValue() const throw(INTERP_KERNEL::Exception); - double norm2() const throw(INTERP_KERNEL::Exception); - double normMax() const throw(INTERP_KERNEL::Exception); + MEDCouplingFieldDouble *buildNewTimeReprFromThis(TypeOfTimeDiscretization td, bool deepCopy) const; + MEDCouplingFieldDouble *nodeToCellDiscretization() const; + MEDCouplingFieldDouble *cellToNodeDiscretization() const; + double getIJ(int tupleId, int compoId) const; + double getIJK(int cellId, int nodeIdInCell, int compoId) const; + void synchronizeTimeWithMesh(); + void setArray(DataArrayDouble *array); + void setEndArray(DataArrayDouble *array); + void setTime(double val, int iteration, int order); + void setStartTime(double val, int iteration, int order); + void setEndTime(double val, int iteration, int order); + void applyLin(double a, double b, int compoId); + void applyLin(double a, double b); + int getNumberOfComponents() const; + int getNumberOfTuples() const; + int getNumberOfValues() const; + void setTimeTolerance(double val); + double getTimeTolerance() const; + void setIteration(int it); + void setEndIteration(int it); + void setOrder(int order); + void setEndOrder(int order); + void setTimeValue(double val); + void setEndTimeValue(double val); + void changeUnderlyingMesh(const MEDCouplingMesh *other, int levOfCheck, double precOnMesh, double eps=1e-15); + void substractInPlaceDM(const MEDCouplingFieldDouble *f, int levOfCheck, double precOnMesh, double eps=1e-15); + bool mergeNodes(double eps, double epsOnVals=1e-15); + bool mergeNodesCenter(double eps, double epsOnVals=1e-15); + bool zipCoords(double epsOnVals=1e-15); + bool zipConnectivity(int compType,double epsOnVals=1e-15); + bool simplexize(int policy); + MEDCouplingFieldDouble *doublyContractedProduct() const; + MEDCouplingFieldDouble *determinant() const; + MEDCouplingFieldDouble *eigenValues() const; + MEDCouplingFieldDouble *eigenVectors() const; + MEDCouplingFieldDouble *inverse() const; + MEDCouplingFieldDouble *trace() const; + MEDCouplingFieldDouble *deviator() const; + MEDCouplingFieldDouble *magnitude() const; + MEDCouplingFieldDouble *maxPerTuple() const; + 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); + void fillFromAnalyticCompo(int nbOfComp, const std::string& func); + void fillFromAnalyticNamedCompo(int nbOfComp, const std::vector& varsOrder, const std::string& func); + void applyFunc(int nbOfComp, const std::string& func); + void applyFuncCompo(int nbOfComp, const std::string& func); + void applyFuncNamedCompo(int nbOfComp, const std::vector& varsOrder, const std::string& func); + void applyFunc(int nbOfComp, double val); + void applyFunc(const std::string& func); + void applyFuncFast32(const std::string& func); + void applyFuncFast64(const std::string& func); + double accumulate(int compId) const; + double getMaxValue() const; + double getMinValue() const; + double getAverageValue() const; + double norm2() const; //do not put a default value to isWAbs because confusion in python with overloaded getWeightedAverageValue method - double getWeightedAverageValue(int compId, bool isWAbs) const throw(INTERP_KERNEL::Exception); - double integral(int compId, bool isWAbs) const throw(INTERP_KERNEL::Exception); - double normL1(int compId) const throw(INTERP_KERNEL::Exception); - double normL2(int compId) const throw(INTERP_KERNEL::Exception); - DataArrayInt *findIdsInRange(double vmin, double vmax) const throw(INTERP_KERNEL::Exception); - MEDCouplingFieldDouble *buildSubPartRange(int begin, int end, int step) const throw(INTERP_KERNEL::Exception); - static MEDCouplingFieldDouble *MergeFields(const MEDCouplingFieldDouble *f1, const MEDCouplingFieldDouble *f2) throw(INTERP_KERNEL::Exception); - static MEDCouplingFieldDouble *MeldFields(const MEDCouplingFieldDouble *f1, const MEDCouplingFieldDouble *f2) throw(INTERP_KERNEL::Exception); - static MEDCouplingFieldDouble *DotFields(const MEDCouplingFieldDouble *f1, const MEDCouplingFieldDouble *f2) throw(INTERP_KERNEL::Exception); - MEDCouplingFieldDouble *dot(const MEDCouplingFieldDouble& other) const throw(INTERP_KERNEL::Exception); - static MEDCouplingFieldDouble *CrossProductFields(const MEDCouplingFieldDouble *f1, const MEDCouplingFieldDouble *f2) throw(INTERP_KERNEL::Exception); - MEDCouplingFieldDouble *crossProduct(const MEDCouplingFieldDouble& other) const throw(INTERP_KERNEL::Exception); - static MEDCouplingFieldDouble *MaxFields(const MEDCouplingFieldDouble *f1, const MEDCouplingFieldDouble *f2) throw(INTERP_KERNEL::Exception); - MEDCouplingFieldDouble *max(const MEDCouplingFieldDouble& other) const throw(INTERP_KERNEL::Exception); - static MEDCouplingFieldDouble *MinFields(const MEDCouplingFieldDouble *f1, const MEDCouplingFieldDouble *f2) throw(INTERP_KERNEL::Exception); - static MEDCouplingFieldDouble *AddFields(const MEDCouplingFieldDouble *f1, const MEDCouplingFieldDouble *f2) throw(INTERP_KERNEL::Exception); - static MEDCouplingFieldDouble *SubstractFields(const MEDCouplingFieldDouble *f1, const MEDCouplingFieldDouble *f2) throw(INTERP_KERNEL::Exception); - static MEDCouplingFieldDouble *MultiplyFields(const MEDCouplingFieldDouble *f1, const MEDCouplingFieldDouble *f2) throw(INTERP_KERNEL::Exception); - static MEDCouplingFieldDouble *DivideFields(const MEDCouplingFieldDouble *f1, const MEDCouplingFieldDouble *f2) throw(INTERP_KERNEL::Exception); - MEDCouplingFieldDouble *min(const MEDCouplingFieldDouble& other) const throw(INTERP_KERNEL::Exception); - MEDCouplingFieldDouble *negate() const throw(INTERP_KERNEL::Exception); + double getWeightedAverageValue(int compId, bool isWAbs) const; + double integral(int compId, bool isWAbs) const; + double normL1(int compId) const; + double normL2(int compId) const; + double normMax(int compId) 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); + static MEDCouplingFieldDouble *DotFields(const MEDCouplingFieldDouble *f1, const MEDCouplingFieldDouble *f2); + MEDCouplingFieldDouble *dot(const MEDCouplingFieldDouble& other) const; + static MEDCouplingFieldDouble *CrossProductFields(const MEDCouplingFieldDouble *f1, const MEDCouplingFieldDouble *f2); + MEDCouplingFieldDouble *crossProduct(const MEDCouplingFieldDouble& other) const; + static MEDCouplingFieldDouble *MaxFields(const MEDCouplingFieldDouble *f1, const MEDCouplingFieldDouble *f2); + MEDCouplingFieldDouble *max(const MEDCouplingFieldDouble& other) const; + static MEDCouplingFieldDouble *MinFields(const MEDCouplingFieldDouble *f1, const MEDCouplingFieldDouble *f2); + static MEDCouplingFieldDouble *AddFields(const MEDCouplingFieldDouble *f1, const MEDCouplingFieldDouble *f2); + static MEDCouplingFieldDouble *SubstractFields(const MEDCouplingFieldDouble *f1, const MEDCouplingFieldDouble *f2); + static MEDCouplingFieldDouble *MultiplyFields(const MEDCouplingFieldDouble *f1, const MEDCouplingFieldDouble *f2); + static MEDCouplingFieldDouble *DivideFields(const MEDCouplingFieldDouble *f1, const MEDCouplingFieldDouble *f2); + MEDCouplingFieldDouble *min(const MEDCouplingFieldDouble& other) const; + MEDCouplingFieldDouble *negate() const; %extend { MEDCouplingFieldDouble(TypeOfField type, TypeOfTimeDiscretization td=ONE_TIME) { @@ -4124,19 +4098,19 @@ namespace MEDCoupling return MEDCouplingFieldDouble::New(ft,td); } - std::string __str__() const throw(INTERP_KERNEL::Exception) + std::string __str__() const { return self->simpleRepr(); } - std::string __repr__() const throw(INTERP_KERNEL::Exception) + std::string __repr__() const { std::ostringstream oss; self->reprQuickOverview(oss); return oss.str(); } - PyObject *isEqualIfNotWhy(const MEDCouplingFieldDouble *other, double meshPrec, double valsPrec) const throw(INTERP_KERNEL::Exception) + PyObject *isEqualIfNotWhy(const MEDCouplingFieldDouble *other, double meshPrec, double valsPrec) const { std::string ret1; bool ret0=self->isEqualIfNotWhy(other,meshPrec,valsPrec,ret1); @@ -4148,13 +4122,13 @@ namespace MEDCoupling return ret; } - MEDCouplingFieldDouble *voronoize(double eps) const throw(INTERP_KERNEL::Exception) + MEDCouplingFieldDouble *voronoize(double eps) const { MCAuto ret(self->voronoize(eps)); return ret.retn(); } - MEDCouplingFieldDouble *convertQuadraticCellsToLinear() const throw(INTERP_KERNEL::Exception) + MEDCouplingFieldDouble *convertQuadraticCellsToLinear() const { MCAuto ret(self->convertQuadraticCellsToLinear()); return ret.retn(); @@ -4167,13 +4141,13 @@ 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); } - DataArrayDouble *getArray() throw(INTERP_KERNEL::Exception) + DataArrayDouble *getArray() { DataArrayDouble *ret=self->getArray(); if(ret) @@ -4181,15 +4155,15 @@ namespace MEDCoupling return ret; } - PyObject *getArrays() const throw(INTERP_KERNEL::Exception) + PyObject *getArrays() const { std::vector arrs=self->getArrays(); 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); } - DataArrayDouble *getEndArray() throw(INTERP_KERNEL::Exception) + DataArrayDouble *getEndArray() { DataArrayDouble *ret=self->getEndArray(); if(ret) @@ -4218,13 +4192,13 @@ namespace MEDCoupling return ret; } - PyObject *getValueOn(PyObject *sl) const throw(INTERP_KERNEL::Exception) + PyObject *getValueOn(PyObject *sl) const { double val; 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 !"); @@ -4232,40 +4206,40 @@ 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 throw(INTERP_KERNEL::Exception) + 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); } - DataArrayDouble *getValueOnMulti(PyObject *locs) const throw(INTERP_KERNEL::Exception) + DataArrayDouble *getValueOnMulti(PyObject *locs) const { const MEDCouplingMesh *mesh(self->getMesh()); 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 throw(INTERP_KERNEL::Exception) + PyObject *getValueOn(PyObject *sl, double time) const { double val; 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 !"); @@ -4274,13 +4248,13 @@ 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); } - void setValues(PyObject *li, PyObject *nbOfTuples=0, PyObject *nbOfComp=0) throw(INTERP_KERNEL::Exception) + void setValues(PyObject *li, PyObject *nbOfTuples=0, PyObject *nbOfComp=0) { if(self->getArray()!=0) MEDCoupling_DataArrayDouble_setValues__SWIG_0(self->getArray(),li,nbOfTuples,nbOfComp); @@ -4292,7 +4266,7 @@ namespace MEDCoupling } } - PyObject *getTime() throw(INTERP_KERNEL::Exception) + PyObject *getTime() { int tmp1,tmp2; double tmp0=self->getTime(tmp1,tmp2); @@ -4303,7 +4277,7 @@ namespace MEDCoupling return res; } - PyObject *getStartTime() throw(INTERP_KERNEL::Exception) + PyObject *getStartTime() { int tmp1,tmp2; double tmp0=self->getStartTime(tmp1,tmp2); @@ -4314,7 +4288,7 @@ namespace MEDCoupling return res; } - PyObject *getEndTime() throw(INTERP_KERNEL::Exception) + PyObject *getEndTime() { int tmp1,tmp2; double tmp0=self->getEndTime(tmp1,tmp2); @@ -4324,124 +4298,131 @@ namespace MEDCoupling PyList_SetItem(res,2,SWIG_From_int(tmp2)); return res; } - PyObject *accumulate() const throw(INTERP_KERNEL::Exception) + 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 throw(INTERP_KERNEL::Exception) + 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 throw(INTERP_KERNEL::Exception) + 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 throw(INTERP_KERNEL::Exception) + 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 throw(INTERP_KERNEL::Exception) + 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); } - void renumberCells(PyObject *li, bool check=true) throw(INTERP_KERNEL::Exception) + PyObject *normMax() const + { + 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) throw(INTERP_KERNEL::Exception) + 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) throw(INTERP_KERNEL::Exception) + 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) throw(INTERP_KERNEL::Exception) + 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); } - MEDCouplingFieldDouble *buildSubPart(PyObject *li) const throw(INTERP_KERNEL::Exception) + MEDCouplingFieldDouble *buildSubPart(PyObject *li) const { return fieldT_buildSubPart(self,li); } - MEDCouplingFieldDouble *__getitem__(PyObject *li) const throw(INTERP_KERNEL::Exception) + MEDCouplingFieldDouble *__getitem__(PyObject *li) const { return fieldT__getitem__(self,li); } - PyObject *getMaxValue2() const throw(INTERP_KERNEL::Exception) + 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 throw(INTERP_KERNEL::Exception) + 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 throw(INTERP_KERNEL::Exception) + 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) throw(INTERP_KERNEL::Exception) + void setSelectedComponents(const MEDCouplingFieldDouble *f, PyObject *li) { - std::vector tmp; + std::vector tmp; convertPyToNewIntArr3(li,tmp); self->setSelectedComponents(f,tmp); } - MEDCouplingFieldDouble *extractSlice3D(PyObject *origin, PyObject *vec, double eps) const throw(INTERP_KERNEL::Exception) + MEDCouplingFieldDouble *extractSlice3D(PyObject *origin, PyObject *vec, double eps) const { double val,val2; 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."; @@ -4451,17 +4432,17 @@ namespace MEDCoupling return self->extractSlice3D(orig,vect,eps); } - MEDCouplingFieldDouble *__add__(PyObject *obj) throw(INTERP_KERNEL::Exception) + MEDCouplingFieldDouble *__add__(PyObject *obj) { return MEDCoupling_MEDCouplingFieldDouble___add__Impl(self,obj); } - MEDCouplingFieldDouble *__radd__(PyObject *obj) throw(INTERP_KERNEL::Exception) + MEDCouplingFieldDouble *__radd__(PyObject *obj) { return MEDCoupling_MEDCouplingFieldDouble___radd__Impl(self,obj); } - MEDCouplingFieldDouble *__sub__(PyObject *obj) throw(INTERP_KERNEL::Exception) + MEDCouplingFieldDouble *__sub__(PyObject *obj) { const char msg[]="Unexpected situation in MEDCouplingFieldDouble.__sub__ ! Expecting a not null MEDCouplingFieldDouble or DataArrayDouble or DataArrayDoubleTuple instance, or a list of double, or a double."; const char msg2[]="in MEDCouplingFieldDouble.__sub__ : self field has no Array of values set !"; @@ -4480,7 +4461,7 @@ namespace MEDCoupling DataArrayDouble *a; DataArrayDoubleTuple *aa; std::vector bb; - int sw; + mcIdType sw; convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb); switch(sw) { @@ -4517,7 +4498,7 @@ namespace MEDCoupling { if(!self->getArray()) throw INTERP_KERNEL::Exception(msg2); - MCAuto aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,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); @@ -4528,22 +4509,22 @@ namespace MEDCoupling } } - MEDCouplingFieldDouble *__rsub__(PyObject *obj) throw(INTERP_KERNEL::Exception) + MEDCouplingFieldDouble *__rsub__(PyObject *obj) { return MEDCoupling_MEDCouplingFieldDouble___rsub__Impl(self,obj); } - MEDCouplingFieldDouble *__mul__(PyObject *obj) throw(INTERP_KERNEL::Exception) + MEDCouplingFieldDouble *__mul__(PyObject *obj) { return MEDCoupling_MEDCouplingFieldDouble___mul__Impl(self,obj); } - MEDCouplingFieldDouble *__rmul__(PyObject *obj) throw(INTERP_KERNEL::Exception) + MEDCouplingFieldDouble *__rmul__(PyObject *obj) { return MEDCoupling_MEDCouplingFieldDouble___rmul__Impl(self,obj); } - MEDCouplingFieldDouble *__div__(PyObject *obj) throw(INTERP_KERNEL::Exception) + MEDCouplingFieldDouble *__div__(PyObject *obj) { const char msg[]="Unexpected situation in MEDCouplingFieldDouble.__div__ ! Expecting a not null MEDCouplingFieldDouble or DataArrayDouble or DataArrayDoubleTuple instance, or a list of double, or a double."; const char msg2[]="in MEDCouplingFieldDouble.__div__ : self field has no Array of values set !"; @@ -4562,7 +4543,7 @@ namespace MEDCoupling DataArrayDouble *a; DataArrayDoubleTuple *aa; std::vector bb; - int sw; + mcIdType sw; convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb); switch(sw) { @@ -4601,7 +4582,7 @@ namespace MEDCoupling { if(!self->getArray()) throw INTERP_KERNEL::Exception(msg2); - MCAuto aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,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); @@ -4612,12 +4593,12 @@ namespace MEDCoupling } } - MEDCouplingFieldDouble *__rdiv__(PyObject *obj) throw(INTERP_KERNEL::Exception) + MEDCouplingFieldDouble *__rdiv__(PyObject *obj) { return MEDCoupling_MEDCouplingFieldDouble___rdiv__Impl(self,obj); } - MEDCouplingFieldDouble *__pow__(PyObject *obj) throw(INTERP_KERNEL::Exception) + MEDCouplingFieldDouble *__pow__(PyObject *obj) { const char msg[]="Unexpected situation in MEDCouplingFieldDouble.__pow__ ! Expecting a not null MEDCouplingFieldDouble or DataArrayDouble or DataArrayDoubleTuple instance, or a list of double, or a double."; const char msg2[]="in MEDCouplingFieldDouble.__pow__ : self field has no Array of values set !"; @@ -4636,7 +4617,7 @@ namespace MEDCoupling DataArrayDouble *a; DataArrayDoubleTuple *aa; std::vector bb; - int sw; + mcIdType sw; convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb); switch(sw) { @@ -4673,7 +4654,7 @@ namespace MEDCoupling { if(!self->getArray()) throw INTERP_KERNEL::Exception(msg2); - MCAuto aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,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); @@ -4684,12 +4665,12 @@ namespace MEDCoupling } } - MEDCouplingFieldDouble *__neg__() const throw(INTERP_KERNEL::Exception) + MEDCouplingFieldDouble *__neg__() const { return self->negate(); } - PyObject *___iadd___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception) + PyObject *___iadd___(PyObject *trueSelf, PyObject *obj) { const char msg[]="Unexpected situation in MEDCouplingFieldDouble.__iadd__ ! Expecting a not null MEDCouplingFieldDouble or DataArrayDouble or DataArrayDoubleTuple instance, or a list of double, or a double."; const char msg2[]="in MEDCouplingFieldDouble.__iadd__ : self field has no Array of values set !"; @@ -4712,7 +4693,7 @@ namespace MEDCoupling DataArrayDouble *a; DataArrayDoubleTuple *aa; std::vector bb; - int sw; + mcIdType sw; convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb); switch(sw) { @@ -4745,7 +4726,7 @@ namespace MEDCoupling { if(!self->getArray()) throw INTERP_KERNEL::Exception(msg2); - MCAuto aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,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; @@ -4755,7 +4736,7 @@ namespace MEDCoupling } } - PyObject *___isub___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception) + PyObject *___isub___(PyObject *trueSelf, PyObject *obj) { const char msg[]="Unexpected situation in MEDCouplingFieldDouble.__isub__ ! Expecting a not null MEDCouplingFieldDouble or DataArrayDouble or DataArrayDoubleTuple instance, or a list of double, or a double."; const char msg2[]="in MEDCouplingFieldDouble.__isub__ : self field has no Array of values set !"; @@ -4778,7 +4759,7 @@ namespace MEDCoupling DataArrayDouble *a; DataArrayDoubleTuple *aa; std::vector bb; - int sw; + mcIdType sw; convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb); switch(sw) { @@ -4811,7 +4792,7 @@ namespace MEDCoupling { if(!self->getArray()) throw INTERP_KERNEL::Exception(msg2); - MCAuto aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,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; @@ -4821,7 +4802,7 @@ namespace MEDCoupling } } - PyObject *___imul___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception) + PyObject *___imul___(PyObject *trueSelf, PyObject *obj) { const char msg[]="Unexpected situation in MEDCouplingFieldDouble.__imul__ ! Expecting a not null MEDCouplingFieldDouble or DataArrayDouble or DataArrayDoubleTuple instance, or a list of double, or a double."; const char msg2[]="in MEDCouplingFieldDouble.__imul__ : self field has no Array of values set !"; @@ -4844,7 +4825,7 @@ namespace MEDCoupling DataArrayDouble *a; DataArrayDoubleTuple *aa; std::vector bb; - int sw; + mcIdType sw; convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb); switch(sw) { @@ -4877,7 +4858,7 @@ namespace MEDCoupling { if(!self->getArray()) throw INTERP_KERNEL::Exception(msg2); - MCAuto aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size()); + MCAuto aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,(int)bb.size()); self->getArray()->multiplyEqual(aaa); Py_XINCREF(trueSelf); return trueSelf; @@ -4887,7 +4868,7 @@ namespace MEDCoupling } } - PyObject *___idiv___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception) + PyObject *___idiv___(PyObject *trueSelf, PyObject *obj) { const char msg[]="Unexpected situation in MEDCouplingFieldDouble.__idiv__ ! Expecting a not null MEDCouplingFieldDouble or DataArrayDouble or DataArrayDoubleTuple instance, or a list of double, or a double."; const char msg2[]="in MEDCouplingFieldDouble.__idiv__ : self field has no Array of values set !"; @@ -4910,7 +4891,7 @@ namespace MEDCoupling DataArrayDouble *a; DataArrayDoubleTuple *aa; std::vector bb; - int sw; + mcIdType sw; convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb); switch(sw) { @@ -4945,7 +4926,7 @@ namespace MEDCoupling { if(!self->getArray()) throw INTERP_KERNEL::Exception(msg2); - MCAuto aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,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; @@ -4955,7 +4936,7 @@ namespace MEDCoupling } } - PyObject *___ipow___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception) + PyObject *___ipow___(PyObject *trueSelf, PyObject *obj) { const char msg[]="Unexpected situation in MEDCouplingFieldDouble.__ipow__ ! Expecting a not null MEDCouplingFieldDouble or DataArrayDouble or DataArrayDoubleTuple instance, or a list of double, or a double."; const char msg2[]="in MEDCouplingFieldDouble.__ipow__ : self field has no Array of values set !"; @@ -4978,7 +4959,7 @@ namespace MEDCoupling DataArrayDouble *a; DataArrayDoubleTuple *aa; std::vector bb; - int sw; + mcIdType sw; convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb); switch(sw) { @@ -5011,7 +4992,7 @@ namespace MEDCoupling { if(!self->getArray()) throw INTERP_KERNEL::Exception(msg2); - MCAuto aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,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; @@ -5021,36 +5002,36 @@ namespace MEDCoupling } } - static MEDCouplingFieldDouble *MergeFields(PyObject *li) throw(INTERP_KERNEL::Exception) + static MEDCouplingFieldDouble *MergeFields(PyObject *li) { std::vector tmp; convertFromPyObjVectorOfObj(li,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,"MEDCouplingFieldDouble",tmp); return MEDCouplingFieldDouble::MergeFields(tmp); } - static std::string WriteVTK(const char *fileName, PyObject *li, bool isBinary=true) throw(INTERP_KERNEL::Exception) + static std::string WriteVTK(const char *fileName, PyObject *li, bool isBinary=true) { std::vector tmp; convertFromPyObjVectorOfObj(li,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,"MEDCouplingFieldDouble",tmp); return MEDCouplingFieldDouble::WriteVTK(fileName,tmp,isBinary); } - PyObject *getTinySerializationInformation() const throw(INTERP_KERNEL::Exception) + PyObject *getTinySerializationInformation() const { return field_getTinySerializationInformation(self); } - PyObject *serialize() const throw(INTERP_KERNEL::Exception) + PyObject *serialize() const { return field_serialize(self); } - PyObject *__getstate__() const throw(INTERP_KERNEL::Exception) + PyObject *__getstate__() const { return field__getstate__(self,MEDCoupling_MEDCouplingFieldDouble_getTinySerializationInformation,MEDCoupling_MEDCouplingFieldDouble_serialize); } - void __setstate__(PyObject *inp) throw(INTERP_KERNEL::Exception) + void __setstate__(PyObject *inp) { field__setstate__(self,inp); } @@ -5062,43 +5043,43 @@ namespace MEDCoupling public: int getNumberOfFields() const; MEDCouplingMultiFields *deepCopy() const; - virtual std::string simpleRepr() const throw(INTERP_KERNEL::Exception); - virtual std::string advancedRepr() const throw(INTERP_KERNEL::Exception); + virtual std::string simpleRepr() const; + virtual std::string advancedRepr() const; virtual bool isEqual(const MEDCouplingMultiFields *other, double meshPrec, double valsPrec) const; virtual bool isEqualWithoutConsideringStr(const MEDCouplingMultiFields *other, double meshPrec, double valsPrec) const; - virtual void checkConsistencyLight() const throw(INTERP_KERNEL::Exception); + virtual void checkConsistencyLight() const; %extend { - std::string __str__() const throw(INTERP_KERNEL::Exception) + std::string __str__() const { return self->simpleRepr(); } - static MEDCouplingMultiFields *New(PyObject *li) throw(INTERP_KERNEL::Exception) + static MEDCouplingMultiFields *New(PyObject *li) { 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); } - MEDCouplingMultiFields(PyObject *li) throw(INTERP_KERNEL::Exception) + MEDCouplingMultiFields(PyObject *li) { 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;igetFieldAtPos(id); if(ret) @@ -5123,12 +5104,12 @@ namespace MEDCoupling else return SWIG_NewPointerObj(SWIG_as_voidptr(0),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, 0 ); } - PyObject *getMeshes() const throw(INTERP_KERNEL::Exception) + PyObject *getMeshes() const { std::vector 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 throw(INTERP_KERNEL::Exception); - bool isEqualWithoutConsideringStr(const MEDCouplingFieldInt *other, double meshPrec, int valsPrec) const throw(INTERP_KERNEL::Exception); - void setTimeUnit(const std::string& unit) throw(INTERP_KERNEL::Exception); - std::string getTimeUnit() const throw(INTERP_KERNEL::Exception); - void setTime(double val, int iteration, int order) throw(INTERP_KERNEL::Exception); - void setArray(DataArrayInt *array) throw(INTERP_KERNEL::Exception); - MEDCouplingFieldInt *deepCopy() const throw(INTERP_KERNEL::Exception); - MEDCouplingFieldInt *clone(bool recDeepCpy) const throw(INTERP_KERNEL::Exception); - MEDCouplingFieldInt *cloneWithMesh(bool recDeepCpy) const throw(INTERP_KERNEL::Exception); - MEDCouplingFieldDouble *convertToDblField() const throw(INTERP_KERNEL::Exception); - MEDCouplingFieldInt *buildSubPartRange(int begin, int end, int step) const throw(INTERP_KERNEL::Exception); + 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(DataArrayInt32 *array); + MEDCouplingFieldInt32 *deepCopy() const; + MEDCouplingFieldInt32 *clone(bool recDeepCpy) const; + MEDCouplingFieldInt32 *cloneWithMesh(bool recDeepCpy) const; + MEDCouplingFieldDouble *convertToDblField() 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 throw(INTERP_KERNEL::Exception) + PyObject *isEqualIfNotWhy(const MEDCouplingFieldInt32 *other, double meshPrec, int valsPrec) const { std::string ret1; bool ret0=self->isEqualIfNotWhy(other,meshPrec,valsPrec,ret1); @@ -5253,37 +5234,37 @@ namespace MEDCoupling return ret; } - std::string __str__() const throw(INTERP_KERNEL::Exception) + std::string __str__() const { return self->simpleRepr(); } - std::string __repr__() const throw(INTERP_KERNEL::Exception) + std::string __repr__() const { std::ostringstream oss; self->reprQuickOverview(oss); return oss.str(); } - MEDCouplingFieldInt *buildSubPart(PyObject *li) const throw(INTERP_KERNEL::Exception) + MEDCouplingFieldInt32 *buildSubPart(PyObject *li) const { return fieldT_buildSubPart(self,li); } - MEDCouplingFieldInt *__getitem__(PyObject *li) const throw(INTERP_KERNEL::Exception) + MEDCouplingFieldInt32 *__getitem__(PyObject *li) const { return fieldT__getitem__(self,li); } - DataArrayInt *getArray() throw(INTERP_KERNEL::Exception) + DataArrayInt32 *getArray() { - DataArrayInt *ret=self->getArray(); + DataArrayInt32 *ret=self->getArray(); if(ret) ret->incrRef(); return ret; } - PyObject *getTime() throw(INTERP_KERNEL::Exception) + PyObject *getTime() { int tmp1,tmp2; double tmp0=self->getTime(tmp1,tmp2); @@ -5294,44 +5275,146 @@ namespace MEDCoupling return res; } - PyObject *getTinySerializationInformation() const throw(INTERP_KERNEL::Exception) + PyObject *getTinySerializationInformation() const { - return field_getTinySerializationInformation(self); + return field_getTinySerializationInformation(self); } - PyObject *serialize() const throw(INTERP_KERNEL::Exception) + PyObject *serialize() const { return field_serialize(self); } - PyObject *__getstate__() const throw(INTERP_KERNEL::Exception) + 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) throw(INTERP_KERNEL::Exception) + void __setstate__(PyObject *inp) { field__setstate__(self,inp); } } }; + 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: static MEDCouplingFieldFloat *New(TypeOfField type, TypeOfTimeDiscretization td=ONE_TIME); static MEDCouplingFieldFloat *New(const MEDCouplingFieldTemplate& ft, TypeOfTimeDiscretization td=ONE_TIME); - bool isEqual(const MEDCouplingFieldFloat *other, double meshPrec, float valsPrec) const throw(INTERP_KERNEL::Exception); - bool isEqualWithoutConsideringStr(const MEDCouplingFieldFloat *other, double meshPrec, float valsPrec) const throw(INTERP_KERNEL::Exception); - void setTimeUnit(const std::string& unit) throw(INTERP_KERNEL::Exception); - std::string getTimeUnit() const throw(INTERP_KERNEL::Exception); - void setTime(double val, int iteration, int order) throw(INTERP_KERNEL::Exception); - void setArray(DataArrayFloat *array) throw(INTERP_KERNEL::Exception); - MEDCouplingFieldFloat *deepCopy() const throw(INTERP_KERNEL::Exception); - MEDCouplingFieldFloat *clone(bool recDeepCpy) const throw(INTERP_KERNEL::Exception); - MEDCouplingFieldFloat *cloneWithMesh(bool recDeepCpy) const throw(INTERP_KERNEL::Exception); - MEDCouplingFieldDouble *convertToDblField() const throw(INTERP_KERNEL::Exception); - MEDCouplingFieldFloat *buildSubPartRange(int begin, int end, int step) const throw(INTERP_KERNEL::Exception); + bool isEqual(const MEDCouplingFieldFloat *other, double meshPrec, float valsPrec) const; + bool isEqualWithoutConsideringStr(const MEDCouplingFieldFloat *other, double meshPrec, float valsPrec) const; + void setTimeUnit(const std::string& unit); + std::string getTimeUnit() const; + void setTime(double val, int iteration, int order); + void setArray(DataArrayFloat *array); + MEDCouplingFieldFloat *deepCopy() const; + MEDCouplingFieldFloat *clone(bool recDeepCpy) const; + MEDCouplingFieldFloat *cloneWithMesh(bool recDeepCpy) const; + MEDCouplingFieldDouble *convertToDblField() const; + MEDCouplingFieldFloat *buildSubPartRange(int begin, int end, int step) const; %extend { MEDCouplingFieldFloat(TypeOfField type, TypeOfTimeDiscretization td=ONE_TIME) { @@ -5343,7 +5426,7 @@ namespace MEDCoupling return MEDCouplingFieldFloat::New(ft,td); } - PyObject *isEqualIfNotWhy(const MEDCouplingFieldFloat *other, double meshPrec, float valsPrec) const throw(INTERP_KERNEL::Exception) + PyObject *isEqualIfNotWhy(const MEDCouplingFieldFloat *other, double meshPrec, float valsPrec) const { std::string ret1; bool ret0=self->isEqualIfNotWhy(other,meshPrec,valsPrec,ret1); @@ -5355,29 +5438,29 @@ namespace MEDCoupling return ret; } - std::string __str__() const throw(INTERP_KERNEL::Exception) + std::string __str__() const { return self->simpleRepr(); } - std::string __repr__() const throw(INTERP_KERNEL::Exception) + std::string __repr__() const { std::ostringstream oss; self->reprQuickOverview(oss); return oss.str(); } - MEDCouplingFieldFloat *buildSubPart(PyObject *li) const throw(INTERP_KERNEL::Exception) + MEDCouplingFieldFloat *buildSubPart(PyObject *li) const { return fieldT_buildSubPart(self,li); } - MEDCouplingFieldFloat *__getitem__(PyObject *li) const throw(INTERP_KERNEL::Exception) + MEDCouplingFieldFloat *__getitem__(PyObject *li) const { return fieldT__getitem__(self,li); } - DataArrayFloat *getArray() throw(INTERP_KERNEL::Exception) + DataArrayFloat *getArray() { DataArrayFloat *ret=self->getArray(); if(ret) @@ -5385,7 +5468,7 @@ namespace MEDCoupling return ret; } - PyObject *getTime() throw(INTERP_KERNEL::Exception) + PyObject *getTime() { int tmp1,tmp2; double tmp0=self->getTime(tmp1,tmp2); @@ -5396,22 +5479,22 @@ namespace MEDCoupling return res; } - PyObject *getTinySerializationInformation() const throw(INTERP_KERNEL::Exception) + PyObject *getTinySerializationInformation() const { return field_getTinySerializationInformation(self); } - PyObject *serialize() const throw(INTERP_KERNEL::Exception) + PyObject *serialize() const { return field_serialize(self); } - PyObject *__getstate__() const throw(INTERP_KERNEL::Exception) + PyObject *__getstate__() const { return field__getstate__(self,MEDCoupling_MEDCouplingFieldFloat_getTinySerializationInformation,MEDCoupling_MEDCouplingFieldFloat_serialize); } - void __setstate__(PyObject *inp) throw(INTERP_KERNEL::Exception) + void __setstate__(PyObject *inp) { field__setstate__(self,inp); } @@ -5428,14 +5511,14 @@ namespace MEDCoupling std::vector getHotSpotsTime() const; %extend { - std::string __str__() const throw(INTERP_KERNEL::Exception) + std::string __str__() const { std::ostringstream oss; self->appendRepr(oss); return oss.str(); } - PyObject *getIdsOnTimeRight(double tm) const throw(INTERP_KERNEL::Exception) + PyObject *getIdsOnTimeRight(double tm) const { int meshId,arrId,arrIdInField,fieldId; self->getIdsOnTimeRight(tm,meshId,arrId,arrIdInField,fieldId); @@ -5447,7 +5530,7 @@ namespace MEDCoupling return res; } - PyObject *getIdsOnTimeLeft(double tm) const throw(INTERP_KERNEL::Exception) + PyObject *getIdsOnTimeLeft(double tm) const { int meshId,arrId,arrIdInField,fieldId; self->getIdsOnTimeLeft(tm,meshId,arrId,arrIdInField,fieldId); @@ -5464,35 +5547,35 @@ namespace MEDCoupling class MEDCouplingFieldOverTime : public MEDCouplingMultiFields { public: - double getTimeTolerance() const throw(INTERP_KERNEL::Exception); + double getTimeTolerance() const; MEDCouplingDefinitionTime getDefinitionTimeZone() const; %extend { - MEDCouplingFieldOverTime(PyObject *li) throw(INTERP_KERNEL::Exception) + MEDCouplingFieldOverTime(PyObject *li) { 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); } - std::string __str__() const throw(INTERP_KERNEL::Exception) + std::string __str__() const { return self->simpleRepr(); } - static MEDCouplingFieldOverTime *New(PyObject *li) throw(INTERP_KERNEL::Exception) - { - 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); - } + static MEDCouplingFieldOverTime *New(PyObject *li) + { + 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); + } } }; @@ -5501,12 +5584,12 @@ namespace MEDCoupling class MEDCouplingCartesianAMRPatchGen : public RefCountObject { public: - int getNumberOfCellsRecursiveWithOverlap() const throw(INTERP_KERNEL::Exception); - int getNumberOfCellsRecursiveWithoutOverlap() const throw(INTERP_KERNEL::Exception); - int getMaxNumberOfLevelsRelativeToThis() const throw(INTERP_KERNEL::Exception); + int getNumberOfCellsRecursiveWithOverlap() const; + int getNumberOfCellsRecursiveWithoutOverlap() const; + int getMaxNumberOfLevelsRelativeToThis() const; %extend { - MEDCouplingCartesianAMRMeshGen *getMesh() const throw(INTERP_KERNEL::Exception) + MEDCouplingCartesianAMRMeshGen *getMesh() const { MEDCouplingCartesianAMRMeshGen *ret(const_cast(self->getMesh())); if(ret) @@ -5519,31 +5602,31 @@ namespace MEDCoupling class MEDCouplingCartesianAMRPatch : public MEDCouplingCartesianAMRPatchGen { public: - int getNumberOfOverlapedCellsForFather() const throw(INTERP_KERNEL::Exception); - bool isInMyNeighborhood(const MEDCouplingCartesianAMRPatch *other, int ghostLev) const throw(INTERP_KERNEL::Exception); - std::vector computeCellGridSt() const throw(INTERP_KERNEL::Exception); + int getNumberOfOverlapedCellsForFather() const; + bool isInMyNeighborhood(const MEDCouplingCartesianAMRPatch *other, int ghostLev) const; + std::vector computeCellGridSt() const; %extend { - PyObject *getBLTRRange() const throw(INTERP_KERNEL::Exception) + 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 throw(INTERP_KERNEL::Exception) + 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) throw(INTERP_KERNEL::Exception) + 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 throw(INTERP_KERNEL::Exception) + MEDCouplingCartesianAMRPatch *__getitem__(mcIdType patchId) const { const MEDCouplingCartesianAMRMeshGen *mesh(self->getMesh()); if(!mesh) @@ -5561,7 +5644,7 @@ namespace MEDCoupling return ret; } - void __delitem__(int patchId) throw(INTERP_KERNEL::Exception) + void __delitem__(mcIdType patchId) { MEDCouplingCartesianAMRMeshGen *mesh(const_cast(self->getMesh())); if(!mesh) @@ -5569,7 +5652,7 @@ namespace MEDCoupling mesh->removePatch(patchId); } - int __len__() const throw(INTERP_KERNEL::Exception) + mcIdType __len__() const { const MEDCouplingCartesianAMRMeshGen *mesh(self->getMesh()); if(!mesh) @@ -5586,55 +5669,55 @@ namespace MEDCoupling class MEDCouplingCartesianAMRMeshGen : public RefCountObject, public TimeLabel { public: - int getAbsoluteLevel() const throw(INTERP_KERNEL::Exception); - int getAbsoluteLevelRelativeTo(const MEDCouplingCartesianAMRMeshGen *ref) const throw(INTERP_KERNEL::Exception); - std::vector getPositionRelativeTo(const MEDCouplingCartesianAMRMeshGen *ref) const throw(INTERP_KERNEL::Exception); - int getSpaceDimension() const throw(INTERP_KERNEL::Exception); - const std::vector& getFactors() const throw(INTERP_KERNEL::Exception); - void setFactors(const std::vector& newFactors) throw(INTERP_KERNEL::Exception); - int getMaxNumberOfLevelsRelativeToThis() const throw(INTERP_KERNEL::Exception); - int getNumberOfCellsAtCurrentLevel() const throw(INTERP_KERNEL::Exception); - int getNumberOfCellsAtCurrentLevelGhost(int ghostLev) const throw(INTERP_KERNEL::Exception); - int getNumberOfCellsRecursiveWithOverlap() const throw(INTERP_KERNEL::Exception); - int getNumberOfCellsRecursiveWithoutOverlap() const throw(INTERP_KERNEL::Exception); - bool isPatchInNeighborhoodOf(int patchId1, int patchId2, int ghostLev) const throw(INTERP_KERNEL::Exception); - virtual void detachFromFather() throw(INTERP_KERNEL::Exception); + 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); + 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 throw(INTERP_KERNEL::Exception); - int getPatchIdFromChildMesh(const MEDCouplingCartesianAMRMeshGen *mesh) const throw(INTERP_KERNEL::Exception); - MEDCouplingUMesh *buildUnstructured() const throw(INTERP_KERNEL::Exception); - DataArrayDouble *extractGhostFrom(int ghostSz, const DataArrayDouble *arr) const throw(INTERP_KERNEL::Exception); - std::vector getPatchIdsInTheNeighborhoodOf(int patchId, int ghostLev) const throw(INTERP_KERNEL::Exception); - MEDCoupling1SGTUMesh *buildMeshFromPatchEnvelop() const throw(INTERP_KERNEL::Exception); - MEDCoupling1SGTUMesh *buildMeshOfDirectChildrenOnly() const throw(INTERP_KERNEL::Exception); - void removeAllPatches() throw(INTERP_KERNEL::Exception); - void removePatch(int patchId) throw(INTERP_KERNEL::Exception); - void createPatchesFromCriterion(const INTERP_KERNEL::BoxSplittingOptions& bso, const DataArrayByte *criterion, const std::vector& factors) throw(INTERP_KERNEL::Exception); - void createPatchesFromCriterion(const INTERP_KERNEL::BoxSplittingOptions& bso, const DataArrayDouble *criterion, const std::vector& factors, double eps) throw(INTERP_KERNEL::Exception); - DataArrayDouble *createCellFieldOnPatch(int patchId, const DataArrayDouble *cellFieldOnThis) const throw(INTERP_KERNEL::Exception); - void fillCellFieldOnPatch(int patchId, const DataArrayDouble *cellFieldOnThis, DataArrayDouble *cellFieldOnPatch, bool isConservative=true) const throw(INTERP_KERNEL::Exception); - void fillCellFieldOnPatchGhost(int patchId, const DataArrayDouble *cellFieldOnThis, DataArrayDouble *cellFieldOnPatch, int ghostLev, bool isConservative=true) const throw(INTERP_KERNEL::Exception); - void fillCellFieldOnPatchOnlyOnGhostZone(int patchId, const DataArrayDouble *cellFieldOnThis, DataArrayDouble *cellFieldOnPatch, int ghostLev) const throw(INTERP_KERNEL::Exception); - 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 throw(INTERP_KERNEL::Exception); - void fillCellFieldComingFromPatchGhost(int patchId, const DataArrayDouble *cellFieldOnPatch, DataArrayDouble *cellFieldOnThis, int ghostLev, bool isConservative=true) const throw(INTERP_KERNEL::Exception); - DataArrayInt *findPatchesInTheNeighborhoodOf(int patchId, int ghostLev) const throw(INTERP_KERNEL::Exception); - std::string buildPythonDumpOfThis() const throw(INTERP_KERNEL::Exception); + mcIdType getNumberOfPatches() const; + mcIdType getPatchIdFromChildMesh(const MEDCouplingCartesianAMRMeshGen *mesh) const; + MEDCouplingUMesh *buildUnstructured() 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(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) throw(INTERP_KERNEL::Exception) + 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); } - PyObject *getPatches() const throw(INTERP_KERNEL::Exception) + 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) @@ -5645,12 +5728,12 @@ namespace MEDCoupling } // agy : don't know why typemap fails here ??? let it in the extend section - PyObject *deepCopy(MEDCouplingCartesianAMRMeshGen *father) const throw(INTERP_KERNEL::Exception) + PyObject *deepCopy(MEDCouplingCartesianAMRMeshGen *father) const { return convertCartesianAMRMesh(self->deepCopy(father), SWIG_POINTER_OWN | 0 ); } - MEDCouplingCartesianAMRPatch *getPatchAtPosition(const std::vector& pos) const throw(INTERP_KERNEL::Exception) + MEDCouplingCartesianAMRPatch *getPatchAtPosition(const std::vector& pos) const { const MEDCouplingCartesianAMRPatch *ret(self->getPatchAtPosition(pos)); MEDCouplingCartesianAMRPatch *ret2(const_cast(ret)); @@ -5659,7 +5742,7 @@ namespace MEDCoupling return ret2; } - MEDCouplingCartesianAMRMeshGen *getMeshAtPosition(const std::vector& pos) const throw(INTERP_KERNEL::Exception) + MEDCouplingCartesianAMRMeshGen *getMeshAtPosition(const std::vector& pos) const { const MEDCouplingCartesianAMRMeshGen *ret(self->getMeshAtPosition(pos)); MEDCouplingCartesianAMRMeshGen *ret2(const_cast(ret)); @@ -5668,34 +5751,34 @@ namespace MEDCoupling return ret2; } - virtual PyObject *positionRelativeToGodFather() const throw(INTERP_KERNEL::Exception) + 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 throw(INTERP_KERNEL::Exception) + 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); return self->buildCellFieldOnRecurseWithoutOverlapWithoutGhost(ghostSz,inp); } - virtual MEDCouplingCartesianAMRMeshGen *getFather() const throw(INTERP_KERNEL::Exception) + virtual MEDCouplingCartesianAMRMeshGen *getFather() const { MEDCouplingCartesianAMRMeshGen *ret(const_cast(self->getFather())); if(ret) @@ -5703,7 +5786,7 @@ namespace MEDCoupling return ret; } - virtual MEDCouplingCartesianAMRMeshGen *getGodFather() const throw(INTERP_KERNEL::Exception) + virtual MEDCouplingCartesianAMRMeshGen *getGodFather() const { MEDCouplingCartesianAMRMeshGen *ret(const_cast(self->getGodFather())); if(ret) @@ -5711,7 +5794,7 @@ namespace MEDCoupling return ret; } - MEDCouplingCartesianAMRPatch *getPatch(int patchId) const throw(INTERP_KERNEL::Exception) + MEDCouplingCartesianAMRPatch *getPatch(mcIdType patchId) const { MEDCouplingCartesianAMRPatch *ret(const_cast(self->getPatch(patchId))); if(ret) @@ -5719,7 +5802,7 @@ namespace MEDCoupling return ret; } - MEDCouplingIMesh *getImageMesh() const throw(INTERP_KERNEL::Exception) + MEDCouplingIMesh *getImageMesh() const { const MEDCouplingIMesh *ret(self->getImageMesh()); if(ret) @@ -5727,7 +5810,7 @@ namespace MEDCoupling return const_cast(ret); } - MEDCouplingCartesianAMRPatch *__getitem__(int patchId) const throw(INTERP_KERNEL::Exception) + MEDCouplingCartesianAMRPatch *__getitem__(mcIdType patchId) const { if(patchId==self->getNumberOfPatches()) { @@ -5742,26 +5825,26 @@ namespace MEDCoupling return ret; } - void fillCellFieldOnPatchGhostAdv(int patchId, const DataArrayDouble *cellFieldOnThis, int ghostLev, PyObject *arrsOnPatches, bool isConservative=true) const throw(INTERP_KERNEL::Exception) + 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) throw(INTERP_KERNEL::Exception) + void __delitem__(mcIdType patchId) { self->removePatch(patchId); } - int __len__() const throw(INTERP_KERNEL::Exception) + mcIdType __len__() const { return self->getNumberOfPatches(); } @@ -5775,43 +5858,43 @@ namespace MEDCoupling class MEDCouplingCartesianAMRMesh : public MEDCouplingCartesianAMRMeshGen { public: - static MEDCouplingCartesianAMRMesh *New(MEDCouplingIMesh *mesh) throw(INTERP_KERNEL::Exception); + static MEDCouplingCartesianAMRMesh *New(MEDCouplingIMesh *mesh); %extend { - static MEDCouplingCartesianAMRMesh *New(const std::string& meshName, int spaceDim, PyObject *nodeStrct, PyObject *origin, PyObject *dxyz) throw(INTERP_KERNEL::Exception) + static MEDCouplingCartesianAMRMesh *New(const std::string& meshName, int spaceDim, PyObject *nodeStrct, PyObject *origin, PyObject *dxyz) { 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); // return MEDCouplingCartesianAMRMesh::New(meshName,spaceDim,nodeStrctPtr,nodeStrctPtr+sz,originPtr,originPtr+sz1,dxyzPtr,dxyzPtr+sz2); } - void createPatchesFromCriterionML(PyObject *bso, const DataArrayDouble *criterion, PyObject *factors, double eps) throw(INTERP_KERNEL::Exception) + void createPatchesFromCriterionML(PyObject *bso, const DataArrayDouble *criterion, PyObject *factors, double eps) { 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); } - MEDCouplingCartesianAMRMesh(const std::string& meshName, int spaceDim, PyObject *nodeStrct, PyObject *origin, PyObject *dxyz) throw(INTERP_KERNEL::Exception) + MEDCouplingCartesianAMRMesh(const std::string& meshName, int spaceDim, PyObject *nodeStrct, PyObject *origin, PyObject *dxyz) { return MEDCoupling_MEDCouplingCartesianAMRMesh_New__SWIG_1(meshName,spaceDim,nodeStrct,origin,dxyz); } - MEDCouplingCartesianAMRMesh(MEDCouplingIMesh *mesh) throw(INTERP_KERNEL::Exception) + MEDCouplingCartesianAMRMesh(MEDCouplingIMesh *mesh) { return MEDCouplingCartesianAMRMesh::New(mesh); } @@ -5821,19 +5904,19 @@ namespace MEDCoupling class MEDCouplingDataForGodFather : public RefCountObject { public: - virtual void synchronizeFineToCoarse() throw(INTERP_KERNEL::Exception); - virtual void synchronizeFineToCoarseBetween(int fromLev, int toLev) throw(INTERP_KERNEL::Exception); - virtual void synchronizeCoarseToFine() throw(INTERP_KERNEL::Exception); - virtual void synchronizeCoarseToFineBetween(int fromLev, int toLev) throw(INTERP_KERNEL::Exception); - virtual void synchronizeAllGhostZones() throw(INTERP_KERNEL::Exception); - virtual void synchronizeAllGhostZonesOfDirectChidrenOf(const MEDCouplingCartesianAMRMeshGen *mesh) throw(INTERP_KERNEL::Exception); - virtual void synchronizeAllGhostZonesAtASpecifiedLevel(int level) throw(INTERP_KERNEL::Exception); - virtual void synchronizeAllGhostZonesAtASpecifiedLevelUsingOnlyFather(int level) throw(INTERP_KERNEL::Exception); - virtual void alloc() throw(INTERP_KERNEL::Exception); - virtual void dealloc() throw(INTERP_KERNEL::Exception); + virtual void synchronizeFineToCoarse(); + virtual void synchronizeFineToCoarseBetween(mcIdType fromLev, mcIdType toLev); + virtual void synchronizeCoarseToFine(); + virtual void synchronizeCoarseToFineBetween(mcIdType fromLev, mcIdType toLev); + virtual void synchronizeAllGhostZones(); + virtual void synchronizeAllGhostZonesOfDirectChidrenOf(const MEDCouplingCartesianAMRMeshGen *mesh); + virtual void synchronizeAllGhostZonesAtASpecifiedLevel(mcIdType level); + virtual void synchronizeAllGhostZonesAtASpecifiedLevelUsingOnlyFather(mcIdType level); + virtual void alloc(); + virtual void dealloc(); %extend { - MEDCouplingCartesianAMRMesh *getMyGodFather() throw(INTERP_KERNEL::Exception) + MEDCouplingCartesianAMRMesh *getMyGodFather() { MEDCouplingCartesianAMRMesh *ret(self->getMyGodFather()); if(ret) @@ -5846,18 +5929,18 @@ namespace MEDCoupling class MEDCouplingAMRAttribute : public MEDCouplingDataForGodFather, public TimeLabel { public: - int getNumberOfLevels() const throw(INTERP_KERNEL::Exception); - MEDCouplingAMRAttribute *deepCopy() const throw(INTERP_KERNEL::Exception); - MEDCouplingAMRAttribute *deepCpyWithoutGodFather() const throw(INTERP_KERNEL::Exception); - MEDCouplingFieldDouble *buildCellFieldOnRecurseWithoutOverlapWithoutGhost(MEDCouplingCartesianAMRMeshGen *mesh, const std::string& fieldName) const throw(INTERP_KERNEL::Exception); - MEDCouplingFieldDouble *buildCellFieldOnWithGhost(MEDCouplingCartesianAMRMeshGen *mesh, const std::string& fieldName) const throw(INTERP_KERNEL::Exception); - MEDCouplingFieldDouble *buildCellFieldOnWithoutGhost(MEDCouplingCartesianAMRMeshGen *mesh, const std::string& fieldName) const throw(INTERP_KERNEL::Exception); - bool changeGodFather(MEDCouplingCartesianAMRMesh *gf) throw(INTERP_KERNEL::Exception); - MEDCouplingAMRAttribute *projectTo(MEDCouplingCartesianAMRMesh *targetGF) const throw(INTERP_KERNEL::Exception); - std::string writeVTHB(const std::string& fileName) const throw(INTERP_KERNEL::Exception); + mcIdType getNumberOfLevels() const; + MEDCouplingAMRAttribute *deepCopy() const; + MEDCouplingAMRAttribute *deepCpyWithoutGodFather() const; + MEDCouplingFieldDouble *buildCellFieldOnRecurseWithoutOverlapWithoutGhost(MEDCouplingCartesianAMRMeshGen *mesh, const std::string& fieldName) const; + MEDCouplingFieldDouble *buildCellFieldOnWithGhost(MEDCouplingCartesianAMRMeshGen *mesh, const std::string& fieldName) const; + MEDCouplingFieldDouble *buildCellFieldOnWithoutGhost(MEDCouplingCartesianAMRMeshGen *mesh, const std::string& fieldName) const; + bool changeGodFather(MEDCouplingCartesianAMRMesh *gf); + MEDCouplingAMRAttribute *projectTo(MEDCouplingCartesianAMRMesh *targetGF) const; + std::string writeVTHB(const std::string& fileName) const; %extend { - static MEDCouplingAMRAttribute *New(MEDCouplingCartesianAMRMesh *gf, PyObject *fieldNames, int ghostLev) throw(INTERP_KERNEL::Exception) + static MEDCouplingAMRAttribute *New(MEDCouplingCartesianAMRMesh *gf, PyObject *fieldNames, mcIdType ghostLev) { std::vector< std::pair > fieldNamesCpp0; std::vector< std::pair > > fieldNamesCpp1; @@ -5875,12 +5958,12 @@ namespace MEDCoupling return ret; } - MEDCouplingAMRAttribute(MEDCouplingCartesianAMRMesh *gf, PyObject *fieldNames, int ghostLev) throw(INTERP_KERNEL::Exception) + MEDCouplingAMRAttribute(MEDCouplingCartesianAMRMesh *gf, PyObject *fieldNames, mcIdType ghostLev) { return MEDCoupling_MEDCouplingAMRAttribute_New(gf,fieldNames,ghostLev); } - DataArrayDouble *getFieldOn(MEDCouplingCartesianAMRMeshGen *mesh, const std::string& fieldName) const throw(INTERP_KERNEL::Exception) + DataArrayDouble *getFieldOn(MEDCouplingCartesianAMRMeshGen *mesh, const std::string& fieldName) const { const DataArrayDouble *ret(self->getFieldOn(mesh,fieldName)); DataArrayDouble *ret2(const_cast(ret)); @@ -5889,16 +5972,16 @@ namespace MEDCoupling return ret2; } - void spillInfoOnComponents(PyObject *compNames) throw(INTERP_KERNEL::Exception) + void spillInfoOnComponents(PyObject *compNames) { std::vector< std::vector > compNamesCpp; convertPyToVectorOfVectorOfString(compNames,compNamesCpp); self->spillInfoOnComponents(compNamesCpp); } - void spillNatures(PyObject *nfs) throw(INTERP_KERNEL::Exception) + 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()); @@ -5908,12 +5991,12 @@ namespace MEDCoupling self->spillNatures(inp00); } - PyObject *retrieveFieldsOn(MEDCouplingCartesianAMRMeshGen *mesh) const throw(INTERP_KERNEL::Exception) + 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;iisEqualIfNotWhy(other,eps,ret1); @@ -5962,7 +6045,7 @@ namespace MEDCoupling return ret; } - DataArrayDouble *getData() throw(INTERP_KERNEL::Exception) + DataArrayDouble *getData() { DataArrayDouble *ret(self->getData()); if(ret) @@ -5970,41 +6053,41 @@ namespace MEDCoupling return ret; } - DenseMatrix *__add__(const DenseMatrix *other) throw(INTERP_KERNEL::Exception) + DenseMatrix *__add__(const DenseMatrix *other) { return MEDCoupling::DenseMatrix::Add(self,other); } - DenseMatrix *__sub__(const DenseMatrix *other) throw(INTERP_KERNEL::Exception) + DenseMatrix *__sub__(const DenseMatrix *other) { return MEDCoupling::DenseMatrix::Substract(self,other); } - DenseMatrix *__mul__(const DenseMatrix *other) throw(INTERP_KERNEL::Exception) + DenseMatrix *__mul__(const DenseMatrix *other) { return MEDCoupling::DenseMatrix::Multiply(self,other); } - DenseMatrix *__mul__(const DataArrayDouble *other) throw(INTERP_KERNEL::Exception) + DenseMatrix *__mul__(const DataArrayDouble *other) { return MEDCoupling::DenseMatrix::Multiply(self,other); } - PyObject *___iadd___(PyObject *trueSelf, const DenseMatrix *other) throw(INTERP_KERNEL::Exception) + PyObject *___iadd___(PyObject *trueSelf, const DenseMatrix *other) { self->addEqual(other); Py_XINCREF(trueSelf); return trueSelf; } - PyObject *___isub___(PyObject *trueSelf, const DenseMatrix *other) throw(INTERP_KERNEL::Exception) + PyObject *___isub___(PyObject *trueSelf, const DenseMatrix *other) { self->substractEqual(other); Py_XINCREF(trueSelf); return trueSelf; } #ifdef WITH_NUMPY - PyObject *toNumPyMatrix() throw(INTERP_KERNEL::Exception) // not const. It is not a bug ! + PyObject *toNumPyMatrix() // not const. It is not a bug ! { PyObject *obj(ToNumPyArrayUnderground(self->getData(),NPY_DOUBLE,"DataArrayDouble",self->getNumberOfRows(),self->getNumberOfCols())); return obj; @@ -6033,20 +6116,51 @@ def MEDCouplingFieldDoubleReduce(self): self.checkConsistencyLight() d=(self.getTypeOfField(),self.getTimeDiscretization()) return MEDCouplingStdReduceFunct,(MEDCouplingFieldDouble,(d,(self.__getstate__()),)) -def MEDCouplingFieldIntReduce(self): +def MEDCouplingFieldInt32Reduce(self): self.checkConsistencyLight() d=(self.getTypeOfField(),self.getTimeDiscretization()) - return MEDCouplingStdReduceFunct,(MEDCouplingFieldInt,(d,(self.__getstate__()),)) + return MEDCouplingStdReduceFunct,(MEDCouplingFieldInt32,(d,(self.__getstate__()),)) +def MEDCouplingFieldInt64Reduce(self): + self.checkConsistencyLight() + d=(self.getTypeOfField(),self.getTimeDiscretization()) + return MEDCouplingStdReduceFunct,(MEDCouplingFieldInt64,(d,(self.__getstate__()),)) def MEDCouplingFieldFloatReduce(self): self.checkConsistencyLight() d=(self.getTypeOfField(),self.getTimeDiscretization()) return MEDCouplingStdReduceFunct,(MEDCouplingFieldFloat,(d,(self.__getstate__()),)) +def MEDCouplingFTReduceFunct(cls,params): + a,b=params + ret=object.__new__(cls) + ret.__init__(*a) + return ret + +def MEDCouplingFieldTemplateReduce(self): + ret = MEDCouplingFieldDouble(self) + nbTuples = self.getNumberOfTuplesExpected() + arr = DataArrayDouble(nbTuples) ; arr[:] = 0. + ret.setArray(arr) + return MEDCouplingFTReduceFunct,(MEDCouplingFieldTemplate,((ret,),())) +# +# Forwarding DataArrayInt functions to MEDCouplingUMesh: +# +MEDCouplingUMesh.ExtractFromIndexedArrays = DataArrayInt.ExtractFromIndexedArrays +MEDCouplingUMesh.ExtractFromIndexedArraysSlice = DataArrayInt.ExtractFromIndexedArraysSlice +MEDCouplingUMesh.SetPartOfIndexedArrays = DataArrayInt.SetPartOfIndexedArrays +MEDCouplingUMesh.SetPartOfIndexedArraysSameIdx = DataArrayInt.SetPartOfIndexedArraysSameIdx +MEDCouplingUMesh.RemoveIdsFromIndexedArrays = DataArrayInt.RemoveIdsFromIndexedArrays +MEDCouplingFieldInt = MEDCouplingFieldInt32 + +if MEDCouplingUse64BitIDs(): + MEDCouplingFieldID = MEDCouplingFieldInt64 +else: + MEDCouplingFieldID = MEDCouplingFieldInt32 + %} %pythoncode %{ import os __filename=os.environ.get('PYTHONSTARTUP') if __filename and os.path.isfile(__filename): - exec(open(__filename).read()) - pass + with open(__filename) as __fp: + exec(__fp.read()) %}