X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FMEDCoupling_Swig%2FMEDCouplingCommon.i;h=e8d5a9db85e5f77ca8b9e03a04022d5f2f4c9c9d;hb=06a1e47785f4fc717910e0ba2fd562a238e5e932;hp=f66c2106ca14ebc00beff87a7de24ac62adb53ac;hpb=bec7037431602509ee55b85e3e54c10b36984153;p=tools%2Fmedcoupling.git diff --git a/src/MEDCoupling_Swig/MEDCouplingCommon.i b/src/MEDCoupling_Swig/MEDCouplingCommon.i index f66c2106c..e8d5a9db8 100644 --- a/src/MEDCoupling_Swig/MEDCouplingCommon.i +++ b/src/MEDCoupling_Swig/MEDCouplingCommon.i @@ -1,4 +1,4 @@ -// Copyright (C) 2007-2016 CEA/DEN, EDF R&D +// Copyright (C) 2017 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 @@ -16,9 +16,7 @@ // // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // -// Author : Anthony Geay (CEA/DEN) - -%module MEDCoupling +// Author : Anthony Geay (EDF R&D) #ifdef WITH_DOCSTRINGS %include MEDCoupling_doc.i @@ -146,6 +144,18 @@ using namespace INTERP_KERNEL; } //$$$$$$$$$$$$$$$$$$ +//////////////////// +%typemap(out) MEDCoupling::MEDCouplingField* +{ + $result=convertField($1,$owner); +} + +%typemap(out) MEDCouplingField* +{ + $result=convertField($1,$owner); +} +//$$$$$$$$$$$$$$$$$$ + //////////////////// %typemap(out) MEDCoupling::MEDCouplingMultiFields* { @@ -188,6 +198,7 @@ using namespace INTERP_KERNEL; %newobject MEDCoupling::MEDCouplingFieldDouble::MergeFields; %newobject MEDCoupling::MEDCouplingFieldDouble::MeldFields; %newobject MEDCoupling::MEDCouplingFieldDouble::convertToIntField; +%newobject MEDCoupling::MEDCouplingFieldDouble::convertToFloatField; %newobject MEDCoupling::MEDCouplingFieldDouble::doublyContractedProduct; %newobject MEDCoupling::MEDCouplingFieldDouble::determinant; %newobject MEDCoupling::MEDCouplingFieldDouble::eigenValues; @@ -314,6 +325,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; @@ -350,6 +362,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; @@ -427,6 +440,9 @@ using namespace INTERP_KERNEL; %newobject MEDCoupling::MEDCouplingGaussLocalization::localizePtsInRefCooForEachCell; %newobject MEDCoupling::MEDCouplingGaussLocalization::buildRefCell; %newobject MEDCoupling::MEDCouplingSkyLineArray::BuildFromPolyhedronConn; +%newobject MEDCoupling::MEDCouplingSkyLineArray::getSuperIndexArray; +%newobject MEDCoupling::MEDCouplingSkyLineArray::getIndexArray; +%newobject MEDCoupling::MEDCouplingSkyLineArray::getValuesArray; %feature("unref") MEDCouplingPointSet "$this->decrRef();" %feature("unref") MEDCouplingMesh "$this->decrRef();" @@ -445,6 +461,8 @@ using namespace INTERP_KERNEL; %feature("unref") MEDCouplingFieldDiscretizationGaussNE "$this->decrRef();" %feature("unref") MEDCouplingFieldDiscretizationKriging "$this->decrRef();" %feature("unref") MEDCouplingFieldDouble "$this->decrRef();" +%feature("unref") MEDCouplingFieldFloat "$this->decrRef();" +%feature("unref") MEDCouplingFieldInt "$this->decrRef();" %feature("unref") MEDCouplingMultiFields "$this->decrRef();" %feature("unref") MEDCouplingFieldTemplate "$this->decrRef();" %feature("unref") MEDCouplingMultiFields "$this->decrRef();" @@ -696,43 +714,36 @@ namespace MEDCoupling return ret; } - PyObject *getCellsContainingPoints(PyObject *p, double eps) const throw(INTERP_KERNEL::Exception) + PyObject *getCellsContainingPointsLinearPartOnlyOnNonDynType(PyObject *p, int nbOfPoints, double eps) const throw(INTERP_KERNEL::Exception) { - MCAuto elts,eltsIndex; + double val; + DataArrayDouble *a; + DataArrayDoubleTuple *aa; + std::vector bb; + int 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 )); return ret; } + PyObject *getCellsContainingPoints(PyObject *p, double eps) const throw(INTERP_KERNEL::Exception) + { + 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 throw(INTERP_KERNEL::Exception) + { + 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 throw(INTERP_KERNEL::Exception) { double val; @@ -948,12 +959,12 @@ namespace MEDCoupling return self->checkTypeConsistencyAndContig(code,idsPerType); } - PyObject *splitProfilePerType(const DataArrayInt *profile) const throw(INTERP_KERNEL::Exception) + PyObject *splitProfilePerType(const DataArrayInt *profile, bool smartPflKiller=true) const throw(INTERP_KERNEL::Exception) { std::vector code; std::vector idsInPflPerType; std::vector idsPerType; - self->splitProfilePerType(profile,code,idsInPflPerType,idsPerType); + self->splitProfilePerType(profile,code,idsInPflPerType,idsPerType,smartPflKiller); PyObject *ret=PyTuple_New(3); // if(code.size()%3!=0) @@ -1067,14 +1078,6 @@ namespace MEDCoupling self->resizeForUnserialization(tinyInfo,a1,a2,littleStrings); } - PyObject *__getnewargs__() throw(INTERP_KERNEL::Exception) - {// put an empty dict in input to say to __new__ to call __init__... - PyObject *ret(PyTuple_New(1)); - PyObject *ret0(PyDict_New()); - PyTuple_SetItem(ret,0,ret0); - return ret; - } - PyObject *__getstate__() const throw(INTERP_KERNEL::Exception) { PyObject *ret0(MEDCoupling_MEDCouplingMesh_getTinySerializationInformation(self)); @@ -1216,12 +1219,11 @@ namespace MEDCoupling int getNumberOf() const; int getLength() const; - DataArrayInt* getSuperIndexArray() const; - DataArrayInt* getIndexArray() const; - DataArrayInt* getValuesArray() const; - void deletePack(const int i, const int j) throw(INTERP_KERNEL::Exception); + void deleteSimplePack(const int i) throw(INTERP_KERNEL::Exception); + void deleteSimplePacks(const DataArrayInt* idx) throw(INTERP_KERNEL::Exception); + %extend { MEDCouplingSkyLineArray() throw(INTERP_KERNEL::Exception) @@ -1248,6 +1250,30 @@ namespace MEDCoupling { return self->simpleRepr(); } + + DataArrayInt *getSuperIndexArray() const + { + DataArrayInt *ret(self->getSuperIndexArray()); + if(ret) + ret->incrRef(); + return ret; + } + + DataArrayInt *getIndexArray() const + { + DataArrayInt *ret(self->getIndexArray()); + if(ret) + ret->incrRef(); + return ret; + } + + DataArrayInt *getValuesArray() const + { + DataArrayInt *ret(self->getValuesArray()); + if(ret) + ret->incrRef(); + return ret; + } PyObject *getSimplePackSafe(int absolutePackId) const throw(INTERP_KERNEL::Exception) { @@ -1281,6 +1307,13 @@ namespace MEDCoupling self->replaceSimplePack(idx, vpack.data(), vpack.data()+vpack.size()); } + void replaceSimplePacks(const DataArrayInt* idx, PyObject *listePacks) throw(INTERP_KERNEL::Exception) + { + std::vector packs; + convertFromPyObjVectorOfObj(listePacks,SWIGTYPE_p_MEDCoupling__DataArrayInt,"DataArrayInt",packs); + self->replaceSimplePacks(idx, packs); + } + void replacePack(const int superIdx, const int idx, PyObject *pack) throw(INTERP_KERNEL::Exception) { std::vector vpack; @@ -1340,6 +1373,7 @@ namespace MEDCoupling 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); %extend { std::string __str__() const throw(INTERP_KERNEL::Exception) @@ -1473,8 +1507,8 @@ namespace MEDCoupling DataArrayDoubleTuple *aa,*aa2; std::vector bb,bb2; int sw; - const char msg[]="Python wrap of MEDCouplingPointSet::findNodesOnLine : 1st paramater for point."; - const char msg2[]="Python wrap of MEDCouplingPointSet::findNodesOnLine : 2nd paramater for vector."; + 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; @@ -1492,8 +1526,8 @@ namespace MEDCoupling DataArrayDoubleTuple *aa,*aa2; std::vector bb,bb2; int sw; - const char msg[]="Python wrap of MEDCouplingPointSet::findNodesOnPlane : 1st paramater for point."; - const char msg2[]="Python wrap of MEDCouplingPointSet::findNodesOnPlane : 2nd paramater for vector."; + 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; @@ -1594,7 +1628,7 @@ namespace MEDCoupling virtual PyObject *findCommonCells(int compType, int startCellId=0) const throw(INTERP_KERNEL::Exception) { - DataArrayInt *v0=0,*v1=0; + DataArrayInt *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 )); @@ -1605,8 +1639,17 @@ namespace MEDCoupling virtual void renumberNodesInConn(PyObject *li) throw(INTERP_KERNEL::Exception) { - 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,SWIGTYPE_p_MEDCoupling__DataArrayInt, 0 | 0 )); if (!SWIG_IsOK(res1)) { int size; @@ -1615,7 +1658,7 @@ namespace MEDCoupling } else { - DataArrayInt *da2=reinterpret_cast< DataArrayInt * >(da); + DataArrayInt *da2(reinterpret_cast< DataArrayInt * >(da)); if(!da2) throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !"); da2->checkAllocated(); @@ -1635,7 +1678,7 @@ namespace MEDCoupling virtual DataArrayInt *fillCellIdsToKeepFromNodeIds(PyObject *li, bool fullyIn) const { - DataArrayInt *ret=0; + DataArrayInt *ret(nullptr); // int szArr,sw,iTypppArr; std::vector stdvecTyyppArr; @@ -1910,6 +1953,7 @@ namespace MEDCoupling DataArrayInt *conformize2D(double eps) throw(INTERP_KERNEL::Exception); DataArrayInt *conformize3D(double eps) throw(INTERP_KERNEL::Exception); DataArrayInt *colinearize2D(double eps) throw(INTERP_KERNEL::Exception); + DataArrayInt *colinearizeKeepingConform2D(double eps) throw(INTERP_KERNEL::Exception); void shiftNodeNumbersInConn(int delta) throw(INTERP_KERNEL::Exception); std::vector getQuadraticStatus() const throw(INTERP_KERNEL::Exception); DataArrayInt *findCellIdsOnBoundary() const throw(INTERP_KERNEL::Exception); @@ -1933,6 +1977,7 @@ namespace MEDCoupling void convertQuadraticCellsToLinear() throw(INTERP_KERNEL::Exception); DataArrayInt *convertLinearCellsToQuadratic(int conversionType=0) throw(INTERP_KERNEL::Exception); void convertDegeneratedCells() throw(INTERP_KERNEL::Exception); + DataArrayInt *convertDegeneratedCellsAndRemoveFlatOnes() 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); @@ -1970,12 +2015,6 @@ namespace MEDCoupling return MEDCouplingUMesh::New(meshName,meshDim); } - // serialization - static PyObject *___new___(PyObject *cls, PyObject *args) throw(INTERP_KERNEL::Exception) - { - return NewMethWrapCallInitOnlyIfEmptyDictInInput(cls,args,"MEDCouplingUMesh"); - } - std::string __str__() const throw(INTERP_KERNEL::Exception) { return self->simpleRepr(); @@ -2356,6 +2395,14 @@ namespace MEDCoupling } } + void attractSeg3MidPtsAroundNodes(double ratio, PyObject *nodeIds) throw(INTERP_KERNEL::Exception) + { + int szArr,sw,iTypppArr; + std::vector stdvecTyyppArr; + const int *nodeIdsPtr(convertIntStarLikePyObjToCppIntStar(nodeIds,sw,szArr,iTypppArr,stdvecTyyppArr)); + self->attractSeg3MidPtsAroundNodes(ratio,nodeIdsPtr,nodeIdsPtr+szArr); + } + PyObject *getLevArrPerCellTypes(PyObject *li) const throw(INTERP_KERNEL::Exception) { int sz; @@ -2505,13 +2552,12 @@ namespace MEDCoupling 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; - PySliceObject *sliC=reinterpret_cast(slic); 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 !"); + 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); @@ -2901,8 +2947,8 @@ namespace MEDCoupling DataArrayDoubleTuple *aa,*aa2; std::vector bb,bb2; int sw; - const char msg[]="Python wrap of MEDCouplingUMesh::buildSlice3D : 1st paramater for origin."; - const char msg2[]="Python wrap of MEDCouplingUMesh::buildSlice3D : 2nd paramater for vector."; + 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); // @@ -2924,8 +2970,8 @@ namespace MEDCoupling DataArrayDoubleTuple *aa,*aa2; std::vector bb,bb2; int sw; - const char msg[]="Python wrap of MEDCouplingUMesh::buildSlice3DSurf : 1st paramater for origin."; - const char msg2[]="Python wrap of MEDCouplingUMesh::buildSlice3DSurf : 2nd paramater for vector."; + 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); // @@ -2944,8 +2990,8 @@ namespace MEDCoupling DataArrayDoubleTuple *aa,*aa2; std::vector bb,bb2; int sw; - const char msg[]="Python wrap of MEDCouplingUMesh::clipSingle3DCellByPlane : 1st paramater for origin."; - const char msg2[]="Python wrap of MEDCouplingUMesh::clipSingle3DCellByPlane : 2nd paramater for vector."; + 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); const double *vect=convertObjToPossibleCpp5_Safe(vec,sw,val2,a2,aa2,bb2,msg2,1,3,true); MCAuto ret(self->clipSingle3DCellByPlane(orig,vect,eps)); @@ -2962,8 +3008,8 @@ namespace MEDCoupling DataArrayDoubleTuple *aa,*aa2; std::vector bb,bb2; int sw; - const char msg[]="Python wrap of MEDCouplingUMesh::getCellIdsCrossingPlane : 1st paramater for origin."; - const char msg2[]="Python wrap of MEDCouplingUMesh::getCellIdsCrossingPlane : 2nd paramater for vector."; + 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); const double *vect=convertObjToPossibleCpp5_Safe(vec,sw,val2,a2,aa2,bb2,msg2,1,spaceDim,true); return self->getCellIdsCrossingPlane(orig,vect,eps); @@ -3035,11 +3081,6 @@ namespace MEDCoupling { return MEDCouplingMappedExtrudedMesh::New(); } - - static PyObject *___new___(PyObject *cls, PyObject *args) throw(INTERP_KERNEL::Exception) - { - return NewMethWrapCallInitOnlyIfEmptyDictInInput(cls,args,"MEDCouplingMappedExtrudedMesh"); - } std::string __str__() const throw(INTERP_KERNEL::Exception) { @@ -3145,11 +3186,6 @@ namespace MEDCoupling return MEDCoupling1SGTUMesh::New(m); } - static PyObject *___new___(PyObject *cls, PyObject *args) throw(INTERP_KERNEL::Exception) - { - return NewMethWrapCallInitOnlyIfEmptyDictInInput(cls,args,"MEDCoupling1SGTUMesh"); - } - std::string __str__() const throw(INTERP_KERNEL::Exception) { return self->simpleRepr(); @@ -3217,11 +3253,6 @@ namespace MEDCoupling return MEDCoupling1DGTUMesh::New(m); } - static PyObject *___new___(PyObject *cls, PyObject *args) throw(INTERP_KERNEL::Exception) - { - return NewMethWrapCallInitOnlyIfEmptyDictInInput(cls,args,"MEDCoupling1DGTUMesh"); - } - std::string __str__() const throw(INTERP_KERNEL::Exception) { return self->simpleRepr(); @@ -3566,11 +3597,6 @@ namespace MEDCoupling { return MEDCouplingCMesh::New(meshName); } - // serialization - static PyObject *___new___(PyObject *cls, PyObject *args) throw(INTERP_KERNEL::Exception) - { - return NewMethWrapCallInitOnlyIfEmptyDictInInput(cls,args,"MEDCouplingCMesh"); - } std::string __str__() const throw(INTERP_KERNEL::Exception) { return self->simpleRepr(); @@ -3610,10 +3636,6 @@ namespace MEDCoupling { return MEDCouplingCurveLinearMesh::New(meshName); } - static PyObject *___new___(PyObject *cls, PyObject *args) throw(INTERP_KERNEL::Exception) - { - return NewMethWrapCallInitOnlyIfEmptyDictInInput(cls,args,"MEDCouplingCurveLinearMesh"); - } std::string __str__() const throw(INTERP_KERNEL::Exception) { return self->simpleRepr(); @@ -3691,11 +3713,6 @@ namespace MEDCoupling return MEDCoupling_MEDCouplingIMesh_New__SWIG_1(meshName,spaceDim,nodeStrct,origin,dxyz); } - static PyObject *___new___(PyObject *cls, PyObject *args) throw(INTERP_KERNEL::Exception) - { - return NewMethWrapCallInitOnlyIfEmptyDictInInput(cls,args,"MEDCouplingIMesh"); - } - void setNodeStruct(PyObject *nodeStrct) throw(INTERP_KERNEL::Exception) { int sw,sz,val0; @@ -3787,8 +3804,6 @@ namespace MEDCoupling public: virtual void checkConsistencyLight() const throw(INTERP_KERNEL::Exception); virtual bool areCompatibleForMerge(const MEDCouplingField *other) const throw(INTERP_KERNEL::Exception); - virtual bool isEqual(const MEDCouplingField *other, double meshPrec, double valsPrec) const throw(INTERP_KERNEL::Exception); - virtual bool isEqualWithoutConsideringStr(const MEDCouplingField *other, double meshPrec, double valsPrec) 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); @@ -3834,18 +3849,6 @@ namespace MEDCoupling return convertIntArrToPyList3(ret); } - PyObject *isEqualIfNotWhy(const MEDCouplingField *other, double meshPrec, double valsPrec) const throw(INTERP_KERNEL::Exception) - { - 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; - } - PyObject *buildSubMeshData(PyObject *li) const throw(INTERP_KERNEL::Exception) { DataArrayInt *ret1=0; @@ -3948,6 +3951,8 @@ namespace MEDCoupling 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); %extend { MEDCouplingFieldTemplate(const MEDCouplingFieldDouble& f) throw(INTERP_KERNEL::Exception) @@ -3981,16 +3986,45 @@ namespace MEDCoupling self->reprQuickOverview(oss); return oss.str(); } + + PyObject *isEqualIfNotWhy(const MEDCouplingFieldTemplate *other, double meshPrec) const throw(INTERP_KERNEL::Exception) + { + std::string ret1; + bool ret0=self->isEqualIfNotWhy(other,meshPrec,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; + } } }; + + template + class MEDCouplingFieldT : public MEDCoupling::MEDCouplingField + { + public: + TypeOfTimeDiscretization getTimeDiscretization() const throw(INTERP_KERNEL::Exception); + protected: + MEDCouplingFieldT(); + ~MEDCouplingFieldT(); + }; + + %template(MEDCouplingFieldTdouble) MEDCoupling::MEDCouplingFieldT; + %template(MEDCouplingFieldTfloat) MEDCoupling::MEDCouplingFieldT; + %template(MEDCouplingFieldTint) MEDCoupling::MEDCouplingFieldT; class MEDCouplingFieldInt; + class MEDCouplingFieldFloat; - class MEDCouplingFieldDouble : public MEDCoupling::MEDCouplingField + class MEDCouplingFieldDouble : public MEDCouplingFieldT { 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); void setTimeUnit(const std::string& unit); std::string getTimeUnit() const; void synchronizeTimeWithSupport() throw(INTERP_KERNEL::Exception); @@ -4000,13 +4034,13 @@ namespace MEDCoupling 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); 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); - TypeOfTimeDiscretization getTimeDiscretization() 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); @@ -4062,12 +4096,12 @@ namespace MEDCoupling 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); //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); + double normMax(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); @@ -4107,6 +4141,18 @@ namespace MEDCoupling self->reprQuickOverview(oss); return oss.str(); } + + PyObject *isEqualIfNotWhy(const MEDCouplingFieldDouble *other, double meshPrec, double valsPrec) const throw(INTERP_KERNEL::Exception) + { + 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; + } MEDCouplingFieldDouble *voronoize(double eps) const throw(INTERP_KERNEL::Exception) { @@ -4319,6 +4365,13 @@ namespace MEDCoupling self->normL2(tmp); return convertDblArrToPyList(tmp,sz); } + PyObject *normMax() const throw(INTERP_KERNEL::Exception) + { + int sz=self->getNumberOfComponents(); + INTERP_KERNEL::AutoPtr tmp=new double[sz]; + self->normMax(tmp); + return convertDblArrToPyList(tmp,sz); + } void renumberCells(PyObject *li, bool check=true) throw(INTERP_KERNEL::Exception) { int szArr,sw,iTypppArr; @@ -4403,8 +4456,8 @@ namespace MEDCoupling std::vector bb,bb2; int sw; int spaceDim=3; - const char msg[]="Python wrap of MEDCouplingFieldDouble::extractSlice3D : 1st paramater for origin."; - const char msg2[]="Python wrap of MEDCouplingFieldDouble::extractSlice3D : 2nd paramater for vector."; + const char msg[]="Python wrap of MEDCouplingFieldDouble::extractSlice3D : 1st parameter for origin."; + const char msg2[]="Python wrap of MEDCouplingFieldDouble::extractSlice3D : 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); // @@ -5005,16 +5058,6 @@ namespace MEDCoupling return field_serialize(self); } - static PyObject *___new___(PyObject *cls, PyObject *args) throw(INTERP_KERNEL::Exception) - { - return NewMethWrapCallInitOnlyIfDictWithSingleEltInInputGeneral(cls,args,"MEDCouplingFieldDouble"); - } - - PyObject *__getnewargs__() throw(INTERP_KERNEL::Exception) - {// put an empty dict in input to say to __new__ to call __init__... - return field__getnewargs__(self); - } - PyObject *__getstate__() const throw(INTERP_KERNEL::Exception) { return field__getstate__(self,MEDCoupling_MEDCouplingFieldDouble_getTinySerializationInformation,MEDCoupling_MEDCouplingFieldDouble_serialize); @@ -5184,11 +5227,13 @@ namespace MEDCoupling } }; - class MEDCouplingFieldInt : public MEDCouplingField + class MEDCouplingFieldInt : 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); @@ -5209,6 +5254,18 @@ namespace MEDCoupling return MEDCouplingFieldInt::New(ft,td); } + PyObject *isEqualIfNotWhy(const MEDCouplingFieldInt *other, double meshPrec, int valsPrec) const throw(INTERP_KERNEL::Exception) + { + 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 throw(INTERP_KERNEL::Exception) { return self->simpleRepr(); @@ -5260,16 +5317,6 @@ namespace MEDCoupling return field_serialize(self); } - static PyObject *___new___(PyObject *cls, PyObject *args) throw(INTERP_KERNEL::Exception) - { - return NewMethWrapCallInitOnlyIfDictWithSingleEltInInputGeneral(cls,args,"MEDCouplingFieldInt"); - } - - PyObject *__getnewargs__() throw(INTERP_KERNEL::Exception) - {// put an empty dict in input to say to __new__ to call __init__... - return field__getnewargs__(self); - } - PyObject *__getstate__() const throw(INTERP_KERNEL::Exception) { return field__getstate__(self,MEDCoupling_MEDCouplingFieldInt_getTinySerializationInformation,MEDCoupling_MEDCouplingFieldInt_serialize); @@ -5282,11 +5329,13 @@ namespace MEDCoupling } }; - class MEDCouplingFieldFloat : public MEDCouplingField + 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); @@ -5307,6 +5356,18 @@ namespace MEDCoupling return MEDCouplingFieldFloat::New(ft,td); } + PyObject *isEqualIfNotWhy(const MEDCouplingFieldFloat *other, double meshPrec, float valsPrec) const throw(INTERP_KERNEL::Exception) + { + 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 throw(INTERP_KERNEL::Exception) { return self->simpleRepr(); @@ -5357,16 +5418,6 @@ namespace MEDCoupling { return field_serialize(self); } - - static PyObject *___new___(PyObject *cls, PyObject *args) throw(INTERP_KERNEL::Exception) - { - return NewMethWrapCallInitOnlyIfDictWithSingleEltInInputGeneral(cls,args,"MEDCouplingFieldFloat"); - } - - PyObject *__getnewargs__() throw(INTERP_KERNEL::Exception) - {// put an empty dict in input to say to __new__ to call __init__... - return field__getnewargs__(self); - } PyObject *__getstate__() const throw(INTERP_KERNEL::Exception) { @@ -5976,10 +6027,39 @@ namespace MEDCoupling }; } +%pythoncode %{ +def MEDCouplingUMeshReduce(self): + return MEDCouplingStdReduceFunct,(MEDCouplingUMesh,((),(self.__getstate__()),)) +def MEDCouplingCMeshReduce(self): + return MEDCouplingStdReduceFunct,(MEDCouplingCMesh,((),(self.__getstate__()),)) +def MEDCouplingIMeshReduce(self): + return MEDCouplingStdReduceFunct,(MEDCouplingIMesh,((),(self.__getstate__()),)) +def MEDCouplingMappedExtrudedMeshReduce(self): + return MEDCouplingStdReduceFunct,(MEDCouplingMappedExtrudedMesh,((),(self.__getstate__()),)) +def MEDCouplingCurveLinearMeshReduce(self): + return MEDCouplingStdReduceFunct,(MEDCouplingCurveLinearMesh,((),(self.__getstate__()),)) +def MEDCoupling1SGTUMeshReduce(self): + return MEDCouplingStdReduceFunct,(MEDCoupling1SGTUMesh,((),(self.__getstate__()),)) +def MEDCoupling1DGTUMeshReduce(self): + return MEDCouplingStdReduceFunct,(MEDCoupling1DGTUMesh,((),(self.__getstate__()),)) +def MEDCouplingFieldDoubleReduce(self): + self.checkConsistencyLight() + d=(self.getTypeOfField(),self.getTimeDiscretization()) + return MEDCouplingStdReduceFunct,(MEDCouplingFieldDouble,(d,(self.__getstate__()),)) +def MEDCouplingFieldIntReduce(self): + self.checkConsistencyLight() + d=(self.getTypeOfField(),self.getTimeDiscretization()) + return MEDCouplingStdReduceFunct,(MEDCouplingFieldInt,(d,(self.__getstate__()),)) +def MEDCouplingFieldFloatReduce(self): + self.checkConsistencyLight() + d=(self.getTypeOfField(),self.getTimeDiscretization()) + return MEDCouplingStdReduceFunct,(MEDCouplingFieldFloat,(d,(self.__getstate__()),)) +%} + %pythoncode %{ import os __filename=os.environ.get('PYTHONSTARTUP') if __filename and os.path.isfile(__filename): - execfile(__filename) + exec(open(__filename).read()) pass %}