From 65fc37047966140c4e1aa88e2ad5bc66107f4409 Mon Sep 17 00:00:00 2001 From: ageay Date: Wed, 3 Nov 2010 06:46:24 +0000 Subject: [PATCH] Small imps. --- src/MEDCoupling/MEDCouplingCMesh.cxx | 222 ++++- src/MEDCoupling/MEDCouplingCMesh.hxx | 5 + .../MEDCouplingFieldDiscretization.cxx | 87 +- .../MEDCouplingFieldDiscretization.hxx | 6 + src/MEDCoupling/MEDCouplingFieldDouble.cxx | 171 +++- src/MEDCoupling/MEDCouplingFieldDouble.hxx | 7 + src/MEDCoupling/MEDCouplingMemArray.cxx | 237 ++++- src/MEDCoupling/MEDCouplingMemArray.hxx | 15 +- src/MEDCoupling/MEDCouplingMesh.cxx | 78 +- .../MEDCouplingTimeDiscretization.cxx | 53 ++ .../MEDCouplingTimeDiscretization.hxx | 4 +- src/MEDCoupling/MEDCouplingUMesh.cxx | 13 +- .../Test/MEDCouplingBasicsTest.hxx | 32 + .../Test/MEDCouplingBasicsTest1.cxx | 4 +- .../Test/MEDCouplingBasicsTest2.cxx | 840 ++++++++++++++++++ src/MEDCoupling_Swig/MEDCouplingBasicsTest.py | 725 ++++++++++++++- src/MEDCoupling_Swig/libMEDCoupling_Swig.i | 258 +++++- src/MEDLoader/Swig/MEDLoaderTest.py | 94 ++ src/MEDLoader/Swig/libMEDLoader_Swig.i | 1 + src/MEDLoader/Test/MEDLoaderTest.cxx | 74 +- src/MEDLoader/Test/MEDLoaderTest.hxx | 4 + 21 files changed, 2746 insertions(+), 184 deletions(-) diff --git a/src/MEDCoupling/MEDCouplingCMesh.cxx b/src/MEDCoupling/MEDCouplingCMesh.cxx index a8aeaf1ef..e7d9bcd3a 100644 --- a/src/MEDCoupling/MEDCouplingCMesh.cxx +++ b/src/MEDCoupling/MEDCouplingCMesh.cxx @@ -18,6 +18,7 @@ // #include "MEDCouplingCMesh.hxx" +#include "MEDCouplingUMesh.hxx" #include "MEDCouplingMemArray.hxx" #include "MEDCouplingFieldDouble.hxx" @@ -236,7 +237,7 @@ void MEDCouplingCMesh::getSplitCellValues(int *res) const for(int l=0;lgetNbOfElems()-1; res[spaceDim-l-1]=val; } @@ -248,7 +249,7 @@ void MEDCouplingCMesh::getSplitNodeValues(int *res) const for(int l=0;lgetNbOfElems(); res[spaceDim-l-1]=val; } @@ -345,7 +346,15 @@ void MEDCouplingCMesh::getNodeIdsOfCell(int cellId, std::vector& conn) cons void MEDCouplingCMesh::getCoordinatesOfNode(int nodeId, std::vector& coo) const { - //not implemented yet + int tmp[3]; + int spaceDim=getSpaceDimension(); + getSplitNodeValues(tmp); + const DataArrayDouble *tabs[3]={getCoordsAt(0),getCoordsAt(1),getCoordsAt(2)}; + int tmp2[3]; + getPosFromId(nodeId,spaceDim,tmp,tmp2); + for(int j=0;jgetConstPointer()[tmp2[j]]); } std::string MEDCouplingCMesh::simpleRepr() const @@ -427,27 +436,94 @@ void MEDCouplingCMesh::setCoords(DataArrayDouble *coordsX, DataArrayDouble *coor declareAsNew(); } +MEDCouplingUMesh *MEDCouplingCMesh::buildUnstructured() const +{ + int spaceDim=getSpaceDimension(); + MEDCouplingUMesh *ret=MEDCouplingUMesh::New(getName(),spaceDim); + DataArrayDouble *coords=getCoordinatesAndOwner(); + ret->setCoords(coords); + coords->decrRef(); + switch(spaceDim) + { + case 1: + fill1DUnstructuredMesh(ret); + break; + case 2: + fill2DUnstructuredMesh(ret); + break; + case 3: + fill3DUnstructuredMesh(ret); + break; + default: + throw INTERP_KERNEL::Exception("MEDCouplingCMesh::buildUnstructured : big problem spacedim must be in 1,2 or 3 !"); + }; + return ret; +} + MEDCouplingMesh *MEDCouplingCMesh::buildPart(const int *start, const int *end) const { - //not implemented yet ! - return 0; + MEDCouplingUMesh *um=buildUnstructured(); + MEDCouplingMesh *ret=um->buildPart(start,end); + um->decrRef(); + return ret; } MEDCouplingMesh *MEDCouplingCMesh::buildPartAndReduceNodes(const int *start, const int *end, DataArrayInt*& arr) const { - //not implemented yet ! - return 0; + MEDCouplingUMesh *um=buildUnstructured(); + MEDCouplingMesh *ret=um->buildPartAndReduceNodes(start,end,arr); + um->decrRef(); + return ret; } void MEDCouplingCMesh::getBoundingBox(double *bbox) const { - //not implemented yet ! + int dim=getSpaceDimension(); + int j=0; + for (int idim=0; idimgetConstPointer(); + int nb=c->getNbOfElems(); + bbox[2*j]=coords[0]; + bbox[2*j+1]=coords[nb-1]; + j++; + } + } } MEDCouplingFieldDouble *MEDCouplingCMesh::getMeasureField(bool isAbs) const { - //not implemented yet ! - return 0; + std::string name="MeasureOfMesh_"; + name+=getName(); + int nbelem=getNumberOfCells(); + MEDCouplingFieldDouble *field=MEDCouplingFieldDouble::New(ON_CELLS); + field->setName(name.c_str()); + DataArrayDouble* array=DataArrayDouble::New(); + array->alloc(nbelem,1); + double *area_vol=array->getPointer(); + field->setArray(array) ; + array->decrRef(); + field->setMesh(const_cast(this)); + int tmp[3]; + getSplitCellValues(tmp); + int dim=getSpaceDimension(); + const double **thisArr=new const double *[dim]; + const DataArrayDouble *thisArr2[3]={_x_array,_y_array,_z_array}; + for(int i=0;igetConstPointer(); + for(int icell=0;icellgetConstPointer(); + int nbOfNodes=getCoordsAt(i)->getNbOfElems(); + double ref=pos[i]; + const double *w=std::find_if(d,d+nbOfNodes,std::bind2nd(std::greater(),ref)); + int w2=std::distance(d,w); + if(w2getPointer(); + int lgth=c->getNbOfElems(); + std::transform(coords,coords+lgth,coords,std::bind2nd(std::minus(),point[i])); + std::transform(coords,coords+lgth,coords,std::bind2nd(std::multiplies(),factor)); + std::transform(coords,coords+lgth,coords,std::bind2nd(std::plus(),point[i])); + c->declareAsNew(); + } + } + updateTime(); } MEDCouplingMesh *MEDCouplingCMesh::mergeMyselfWith(const MEDCouplingMesh *other) const @@ -566,6 +671,95 @@ void MEDCouplingCMesh::renumberCells(const int *old2NewBg, bool check) throw(INT throw INTERP_KERNEL::Exception("Functionnality of renumbering cell not available for CMesh !"); } +void MEDCouplingCMesh::fill1DUnstructuredMesh(MEDCouplingUMesh *m) const +{ + const DataArrayDouble *c=getCoordsAt(0); + int nbOfCells=c->getNbOfElems()-1; + DataArrayInt *connI=DataArrayInt::New(); + connI->alloc(nbOfCells+1,1); + int *ci=connI->getPointer(); + DataArrayInt *conn=DataArrayInt::New(); + conn->alloc(3*nbOfCells,1); + ci[0]=0; + int *cp=conn->getPointer(); + for(int i=0;isetConnectivity(conn,connI,true); + conn->decrRef(); + connI->decrRef(); +} + +void MEDCouplingCMesh::fill2DUnstructuredMesh(MEDCouplingUMesh *m) const +{ + const DataArrayDouble *c1=getCoordsAt(0); + const DataArrayDouble *c2=getCoordsAt(1); + int n1=c1->getNbOfElems()-1; + int n2=c2->getNbOfElems()-1; + DataArrayInt *connI=DataArrayInt::New(); + connI->alloc(n1*n2+1,1); + int *ci=connI->getPointer(); + DataArrayInt *conn=DataArrayInt::New(); + conn->alloc(5*n1*n2,1); + ci[0]=0; + int *cp=conn->getPointer(); + int pos=0; + for(int j=0;jsetConnectivity(conn,connI,true); + conn->decrRef(); + connI->decrRef(); +} + +void MEDCouplingCMesh::fill3DUnstructuredMesh(MEDCouplingUMesh *m) const +{ + const DataArrayDouble *c1=getCoordsAt(0); + const DataArrayDouble *c2=getCoordsAt(1); + const DataArrayDouble *c3=getCoordsAt(2); + int n1=c1->getNbOfElems()-1; + int n2=c2->getNbOfElems()-1; + int n3=c3->getNbOfElems()-1; + DataArrayInt *connI=DataArrayInt::New(); + connI->alloc(n1*n2*n3+1,1); + int *ci=connI->getPointer(); + DataArrayInt *conn=DataArrayInt::New(); + conn->alloc(9*n1*n2*n3,1); + ci[0]=0; + int *cp=conn->getPointer(); + int pos=0; + for(int k=0;ksetConnectivity(conn,connI,true); + conn->decrRef(); + connI->decrRef(); +} + void MEDCouplingCMesh::getTinySerializationInformation(std::vector& tinyInfo, std::vector& littleStrings) const { tinyInfo.clear(); diff --git a/src/MEDCoupling/MEDCouplingCMesh.hxx b/src/MEDCoupling/MEDCouplingCMesh.hxx index 3cdee7c39..434091f41 100644 --- a/src/MEDCoupling/MEDCouplingCMesh.hxx +++ b/src/MEDCoupling/MEDCouplingCMesh.hxx @@ -26,6 +26,7 @@ namespace ParaMEDMEM { class DataArrayDouble; + class MEDCouplingUMesh; class MEDCOUPLING_EXPORT MEDCouplingCMesh : public MEDCouplingMesh { @@ -62,6 +63,7 @@ namespace ParaMEDMEM DataArrayDouble *coordsY=0, DataArrayDouble *coordsZ=0); // tools + MEDCouplingUMesh *buildUnstructured() const; MEDCouplingMesh *buildPart(const int *start, const int *end) const; MEDCouplingMesh *buildPartAndReduceNodes(const int *start, const int *end, DataArrayInt*& arr) const; void getBoundingBox(double *bbox) const; @@ -76,6 +78,9 @@ namespace ParaMEDMEM DataArrayDouble *getCoordinatesAndOwner() const; DataArrayDouble *getBarycenterAndOwner() const; void renumberCells(const int *old2NewBg, bool check) throw(INTERP_KERNEL::Exception); + void fill1DUnstructuredMesh(MEDCouplingUMesh *m) const; + void fill2DUnstructuredMesh(MEDCouplingUMesh *m) const; + void fill3DUnstructuredMesh(MEDCouplingUMesh *m) const; //some useful methods void getSplitCellValues(int *res) const; void getSplitNodeValues(int *res) const; diff --git a/src/MEDCoupling/MEDCouplingFieldDiscretization.cxx b/src/MEDCoupling/MEDCouplingFieldDiscretization.cxx index cadfb04f4..dfa7049cc 100644 --- a/src/MEDCoupling/MEDCouplingFieldDiscretization.cxx +++ b/src/MEDCoupling/MEDCouplingFieldDiscretization.cxx @@ -254,6 +254,40 @@ void MEDCouplingFieldDiscretization::getCellIdsHavingGaussLocalization(int locId throw INTERP_KERNEL::Exception("Invalid method for the corresponding field discretization : available only for GaussPoint discretization !"); } +void MEDCouplingFieldDiscretization::renumberEntitiesFromO2NArr(const int *old2NewPtr, DataArrayDouble *arr, const char *msg) +{ + int oldNbOfElems=arr->getNumberOfTuples(); + int nbOfComp=arr->getNumberOfComponents(); + int newNbOfTuples=(*std::max_element(old2NewPtr,old2NewPtr+oldNbOfElems))+1; + DataArrayDouble *arrCpy=arr->deepCopy(); + const double *ptSrc=arrCpy->getConstPointer(); + arr->reAlloc(newNbOfTuples); + double *ptToFill=arr->getPointer(); + std::fill(ptToFill,ptToFill+nbOfComp*newNbOfTuples,std::numeric_limits::max()); + for(int i=0;i=0)//if newNb<0 the node is considered as out. + { + if(std::find_if(ptToFill+newNb*nbOfComp,ptToFill+(newNb+1)*nbOfComp,std::bind2nd(std::not_equal_to(),std::numeric_limits::max())) + ==ptToFill+(newNb+1)*nbOfComp) + std::copy(ptSrc+i*nbOfComp,ptSrc+(i+1)*nbOfComp,ptToFill+newNb*nbOfComp); + else + { + if(!std::equal(ptSrc+i*nbOfComp,ptSrc+(i+1)*nbOfComp,ptToFill+newNb*nbOfComp)) + { + arrCpy->decrRef(); + std::ostringstream oss; + oss << msg << " " << i << " and " << std::find(old2NewPtr,old2NewPtr+i,newNb)-old2NewPtr + << " have been merged and " << msg << " field on them are different !"; + throw INTERP_KERNEL::Exception(oss.str().c_str()); + } + } + } + } + arrCpy->decrRef(); +} + MEDCouplingFieldDiscretization::~MEDCouplingFieldDiscretization() { } @@ -356,6 +390,11 @@ void MEDCouplingFieldDiscretizationP0::renumberValuesOnNodes(const int *, DataAr { } +void MEDCouplingFieldDiscretizationP0::renumberValuesOnCells(const MEDCouplingMesh *mesh, const int *old2New, DataArrayDouble *arr) const +{ + renumberEntitiesFromO2NArr(old2New,arr,"Cell"); +} + /*! * This method returns a submesh of 'mesh' instance constituting cell ids contained in array defined as an interval [start;end). * @param di is an array returned that specifies entity ids (here cells ids) in mesh 'mesh' of entity in returned submesh. @@ -482,33 +521,14 @@ void MEDCouplingFieldDiscretizationP1::getValueOnPos(const DataArrayDouble *arr, void MEDCouplingFieldDiscretizationP1::renumberValuesOnNodes(const int *old2NewPtr, DataArrayDouble *arr) const { - int oldNbOfElems=arr->getNumberOfTuples(); - int nbOfComp=arr->getNumberOfComponents(); - int newNbOfTuples=(*std::max_element(old2NewPtr,old2NewPtr+oldNbOfElems))+1; - DataArrayDouble *arrCpy=arr->deepCopy(); - const double *ptSrc=arrCpy->getConstPointer(); - arr->reAlloc(newNbOfTuples); - double *ptToFill=arr->getPointer(); - std::fill(ptToFill,ptToFill+nbOfComp*newNbOfTuples,std::numeric_limits::max()); - for(int i=0;i(),std::numeric_limits::max())) - ==ptToFill+(newNb+1)*nbOfComp) - std::copy(ptSrc+i*nbOfComp,ptSrc+(i+1)*nbOfComp,ptToFill+newNb*nbOfComp); - else - { - if(!std::equal(ptSrc+i*nbOfComp,ptSrc+(i+1)*nbOfComp,ptToFill+newNb*nbOfComp)) - { - arrCpy->decrRef(); - std::ostringstream oss; - oss << "Node " << i << " and " << std::find(old2NewPtr,old2NewPtr+i,newNb)-old2NewPtr - << " have been merged and nodal field on them are different !"; - throw INTERP_KERNEL::Exception(oss.str().c_str()); - } - } - } - arrCpy->decrRef(); + renumberEntitiesFromO2NArr(old2NewPtr,arr,"Node"); +} + +/*! + * Nothing to do it's not a bug. + */ +void MEDCouplingFieldDiscretizationP1::renumberValuesOnCells(const MEDCouplingMesh *mesh, const int *old2New, DataArrayDouble *arr) const +{ } /*! @@ -519,6 +539,9 @@ void MEDCouplingFieldDiscretizationP1::renumberValuesOnNodes(const int *old2NewP MEDCouplingMesh *MEDCouplingFieldDiscretizationP1::buildSubMeshData(const MEDCouplingMesh *mesh, const int *start, const int *end, DataArrayInt *&di) const { MEDCouplingMesh *ret=mesh->buildPartAndReduceNodes(start,end,di); + DataArrayInt *di2=di->invertArrayO2N2N2O(ret->getNumberOfNodes()); + di->decrRef(); + di=di2; return ret; } @@ -853,6 +876,11 @@ void MEDCouplingFieldDiscretizationGauss::renumberValuesOnNodes(const int *, Dat { } +void MEDCouplingFieldDiscretizationGauss::renumberValuesOnCells(const MEDCouplingMesh *mesh, const int *old2New, DataArrayDouble *arr) const +{ + throw INTERP_KERNEL::Exception("Not implemented yet !"); +} + void MEDCouplingFieldDiscretizationGauss::setGaussLocalizationOnType(const MEDCouplingMesh *m, INTERP_KERNEL::NormalizedCellType type, const std::vector& refCoo, const std::vector& gsCoo, const std::vector& wg) throw(INTERP_KERNEL::Exception) { @@ -1147,6 +1175,11 @@ void MEDCouplingFieldDiscretizationGaussNE::renumberValuesOnNodes(const int *, D { } +void MEDCouplingFieldDiscretizationGaussNE::renumberValuesOnCells(const MEDCouplingMesh *mesh, const int *old2New, DataArrayDouble *arr) const +{ + throw INTERP_KERNEL::Exception("Not implemented yet !"); +} + MEDCouplingFieldDiscretizationGaussNE::MEDCouplingFieldDiscretizationGaussNE(const MEDCouplingFieldDiscretizationGaussNE& other):MEDCouplingFieldDiscretization(other) { } diff --git a/src/MEDCoupling/MEDCouplingFieldDiscretization.hxx b/src/MEDCoupling/MEDCouplingFieldDiscretization.hxx index 0e502cc35..316fa753d 100644 --- a/src/MEDCoupling/MEDCouplingFieldDiscretization.hxx +++ b/src/MEDCoupling/MEDCouplingFieldDiscretization.hxx @@ -67,6 +67,7 @@ namespace ParaMEDMEM virtual void getValueOnPos(const DataArrayDouble *arr, const MEDCouplingMesh *mesh, int i, int j, int k, double *res) const = 0; virtual MEDCouplingMesh *buildSubMeshData(const MEDCouplingMesh *mesh, const int *start, const int *end, DataArrayInt *&di) const = 0; virtual void renumberValuesOnNodes(const int *old2New, DataArrayDouble *arr) const = 0; + virtual void renumberValuesOnCells(const MEDCouplingMesh *mesh, const int *old2New, DataArrayDouble *arr) const = 0; virtual void getSerializationIntArray(DataArrayInt *& arr) const; virtual void getTinySerializationIntInformation(std::vector& tinyInfo) const; virtual void getTinySerializationDbleInformation(std::vector& tinyInfo) const; @@ -86,6 +87,7 @@ namespace ParaMEDMEM virtual ~MEDCouplingFieldDiscretization(); protected: MEDCouplingFieldDiscretization(); + static void renumberEntitiesFromO2NArr(const int *old2NewPtr, DataArrayDouble *arr, const char *msg); protected: double _precision; static const double DFLT_PRECISION; @@ -110,6 +112,7 @@ namespace ParaMEDMEM void getValueOn(const DataArrayDouble *arr, const MEDCouplingMesh *mesh, const double *loc, double *res) const; void getValueOnPos(const DataArrayDouble *arr, const MEDCouplingMesh *mesh, int i, int j, int k, double *res) const; void renumberValuesOnNodes(const int *old2New, DataArrayDouble *arr) const; + void renumberValuesOnCells(const MEDCouplingMesh *mesh, const int *old2New, DataArrayDouble *arr) const; MEDCouplingMesh *buildSubMeshData(const MEDCouplingMesh *mesh, const int *start, const int *end, DataArrayInt *&di) const; public: static const char REPR[]; @@ -136,6 +139,7 @@ namespace ParaMEDMEM void getValueOnPos(const DataArrayDouble *arr, const MEDCouplingMesh *mesh, int i, int j, int k, double *res) const; MEDCouplingMesh *buildSubMeshData(const MEDCouplingMesh *mesh, const int *start, const int *end, DataArrayInt *&di) const; void renumberValuesOnNodes(const int *old2New, DataArrayDouble *arr) const; + void renumberValuesOnCells(const MEDCouplingMesh *mesh, const int *old2New, DataArrayDouble *arr) const; public: static const char REPR[]; static const TypeOfField TYPE; @@ -190,6 +194,7 @@ namespace ParaMEDMEM void getValueOnPos(const DataArrayDouble *arr, const MEDCouplingMesh *mesh, int i, int j, int k, double *res) const; MEDCouplingMesh *buildSubMeshData(const MEDCouplingMesh *mesh, const int *start, const int *end, DataArrayInt *&di) const; void renumberValuesOnNodes(const int *old2New, DataArrayDouble *arr) const; + void renumberValuesOnCells(const MEDCouplingMesh *mesh, const int *old2New, DataArrayDouble *arr) const; void setGaussLocalizationOnType(const MEDCouplingMesh *m, INTERP_KERNEL::NormalizedCellType type, const std::vector& refCoo, const std::vector& gsCoo, const std::vector& wg) throw(INTERP_KERNEL::Exception); void setGaussLocalizationOnCells(const MEDCouplingMesh *m, const int *begin, const int *end, const std::vector& refCoo, @@ -238,6 +243,7 @@ namespace ParaMEDMEM void getValueOnPos(const DataArrayDouble *arr, const MEDCouplingMesh *mesh, int i, int j, int k, double *res) const; MEDCouplingMesh *buildSubMeshData(const MEDCouplingMesh *mesh, const int *start, const int *end, DataArrayInt *&di) const; void renumberValuesOnNodes(const int *old2New, DataArrayDouble *arr) const; + void renumberValuesOnCells(const MEDCouplingMesh *mesh, const int *old2New, DataArrayDouble *arr) const; protected: MEDCouplingFieldDiscretizationGaussNE(const MEDCouplingFieldDiscretizationGaussNE& other); public: diff --git a/src/MEDCoupling/MEDCouplingFieldDouble.cxx b/src/MEDCoupling/MEDCouplingFieldDouble.cxx index 5ba6492a2..691462d50 100644 --- a/src/MEDCoupling/MEDCouplingFieldDouble.cxx +++ b/src/MEDCoupling/MEDCouplingFieldDouble.cxx @@ -18,7 +18,7 @@ // #include "MEDCouplingFieldDouble.hxx" -#include "MEDCouplingPointSet.hxx" +#include "MEDCouplingUMesh.hxx" #include "MEDCouplingTimeDiscretization.hxx" #include "MEDCouplingFieldDiscretization.hxx" #include "MEDCouplingAutoRefCountObjectPtr.hxx" @@ -261,7 +261,8 @@ void MEDCouplingFieldDouble::renumberNodesWithoutMesh(const int *old2NewBg) thro std::vector arrays; _time_discr->getArrays(arrays); for(std::vector::const_iterator iter=arrays.begin();iter!=arrays.end();iter++) - _type->renumberValuesOnNodes(old2NewBg,*iter); + if(*iter) + _type->renumberValuesOnNodes(old2NewBg,*iter); } /*! @@ -406,6 +407,38 @@ double MEDCouplingFieldDouble::getMaxValue() const throw(INTERP_KERNEL::Exceptio return ret; } +/*! + * This method is an extension of ParaMEDMEM::MEDCouplingFieldDouble::getMaxValue method because the returned + * value is the same but this method also returns to you a tupleIds object which the caller have the responsibility + * to deal with. The main difference is that the returned tupleIds is those corresponding the first set array. + * If you have more than one array set (in LINEAR_TIME instance for example) only the first not null array will be used + * to compute tupleIds. + */ +double MEDCouplingFieldDouble::getMaxValue2(DataArrayInt*& tupleIds) const throw(INTERP_KERNEL::Exception) +{ + std::vector arrays; + _time_discr->getArrays(arrays); + double ret=-std::numeric_limits::max(); + bool isExistingArr=false; + tupleIds=0; + for(std::vector::const_iterator iter=arrays.begin();iter!=arrays.end();iter++) + { + if(*iter) + { + isExistingArr=true; + DataArrayInt *tmp; + ret=std::max(ret,(*iter)->getMaxValue2(tmp)); + if(!tupleIds) + tupleIds=tmp; + else + tmp->decrRef(); + } + } + if(!isExistingArr) + throw INTERP_KERNEL::Exception("getMaxValue2 : No arrays defined !"); + return ret; +} + /*! * This method returns the min value in 'this'. 'This' is expected to be a field with exactly \b one component. If not an exception will be thrown. * To getMinValue on vector field applyFunc is needed before. This method looks only on all arrays stored in 'this->_time_discr'. @@ -431,6 +464,38 @@ double MEDCouplingFieldDouble::getMinValue() const throw(INTERP_KERNEL::Exceptio return ret; } +/*! + * This method is an extension of ParaMEDMEM::MEDCouplingFieldDouble::getMinValue method because the returned + * value is the same but this method also returns to you a tupleIds object which the caller have the responsibility + * to deal with. The main difference is that the returned tupleIds is those corresponding the first set array. + * If you have more than one array set (in LINEAR_TIME instance for example) only the first not null array will be used + * to compute tupleIds. + */ +double MEDCouplingFieldDouble::getMinValue2(DataArrayInt*& tupleIds) const throw(INTERP_KERNEL::Exception) +{ + std::vector arrays; + _time_discr->getArrays(arrays); + double ret=-std::numeric_limits::max(); + bool isExistingArr=false; + tupleIds=0; + for(std::vector::const_iterator iter=arrays.begin();iter!=arrays.end();iter++) + { + if(*iter) + { + isExistingArr=true; + DataArrayInt *tmp; + ret=std::max(ret,(*iter)->getMinValue2(tmp)); + if(!tupleIds) + tupleIds=tmp; + else + tmp->decrRef(); + } + } + if(!isExistingArr) + throw INTERP_KERNEL::Exception("getMinValue2 : No arrays defined !"); + return ret; +} + /*! * This method returns the average value in 'this'. 'This' is expected to be a field with exactly \b one component. If not an exception will be thrown. * To getAverageValue on vector field applyFunc is needed before. This method looks only \b default array \b and \b only \b default. @@ -633,6 +698,46 @@ void MEDCouplingFieldDouble::applyLin(double a, double b, int compoId) _time_discr->applyLin(a,b,compoId); } +/*! + * This method sets 'this' to a uniform scalar field with one component. + * All tuples will have the same value 'value'. + * An exception is thrown if no underlying mesh is defined. + */ +MEDCouplingFieldDouble &MEDCouplingFieldDouble::operator=(double value) throw(INTERP_KERNEL::Exception) +{ + if(!_mesh) + throw INTERP_KERNEL::Exception("MEDCouplingFieldDouble::operator= : no mesh defined !"); + int nbOfTuple=_type->getNumberOfTuples(_mesh); + _time_discr->setUniformValue(nbOfTuple,value); + return *this; +} + +/*! + * This method is very similar to this one MEDCouplingMesh::fillFromAnalytic. + * The main difference is that the field as been started to be constructed here. + * An exception is throw if no underlying mesh is set before the call of this method. + */ +void MEDCouplingFieldDouble::fillFromAnalytic(int nbOfComp, FunctionToEvaluate func) throw(INTERP_KERNEL::Exception) +{ + if(!_mesh) + throw INTERP_KERNEL::Exception("MEDCouplingFieldDouble::fillFromAnalytic : no mesh defined !"); + MEDCouplingAutoRefCountObjectPtr loc=_type->getLocalizationOfDiscValues(_mesh); + _time_discr->fillFromAnalytic(loc,nbOfComp,func); +} + +/*! + * This method is very similar to this one MEDCouplingMesh::fillFromAnalytic. + * The main difference is that the field as been started to be constructed here. + * An exception is throw if no underlying mesh is set before the call of this method. + */ +void MEDCouplingFieldDouble::fillFromAnalytic(int nbOfComp, const char *func) throw(INTERP_KERNEL::Exception) +{ + if(!_mesh) + throw INTERP_KERNEL::Exception("MEDCouplingFieldDouble::fillFromAnalytic : no mesh defined !"); + MEDCouplingAutoRefCountObjectPtr loc=_type->getLocalizationOfDiscValues(_mesh); + _time_discr->fillFromAnalytic(loc,nbOfComp,func); +} + /*! * Applyies the function specified by pointer 'func' on each tuples on all arrays contained in _time_discr. * If '*func' returns false during one evaluation an exception will be thrown. @@ -665,13 +770,18 @@ void MEDCouplingFieldDouble::applyFunc(const char *func) /*! * Applyies the function specified by the string repr 'func' on each tuples on all arrays contained in _time_discr. * The field will contain exactly the same number of components after the call. - * Use is not warranted and can cause SIGSEGV ! + * Use is not warranted for the moment ! */ void MEDCouplingFieldDouble::applyFuncFast32(const char *func) throw(INTERP_KERNEL::Exception) { _time_discr->applyFuncFast32(func); } +/*! + * Applyies the function specified by the string repr 'func' on each tuples on all arrays contained in _time_discr. + * The field will contain exactly the same number of components after the call. + * Use is not warranted for the moment ! + */ void MEDCouplingFieldDouble::applyFuncFast64(const char *func) throw(INTERP_KERNEL::Exception) { _time_discr->applyFuncFast64(func); @@ -877,7 +987,7 @@ bool MEDCouplingFieldDouble::mergeNodes(double eps) throw(INTERP_KERNEL::Excepti { const MEDCouplingPointSet *meshC=dynamic_cast(_mesh); if(!meshC) - throw INTERP_KERNEL::Exception("Invalid mesh to apply mergeNodes on it !"); + throw INTERP_KERNEL::Exception("Invalid support mesh to apply mergeNodes on it : must be a MEDCouplingPointSet one !"); MEDCouplingAutoRefCountObjectPtr meshC2((MEDCouplingPointSet *)meshC->deepCpy()); bool ret; int ret2; @@ -887,11 +997,62 @@ bool MEDCouplingFieldDouble::mergeNodes(double eps) throw(INTERP_KERNEL::Excepti std::vector arrays; _time_discr->getArrays(arrays); for(std::vector::const_iterator iter=arrays.begin();iter!=arrays.end();iter++) - _type->renumberValuesOnNodes(arr->getConstPointer(),*iter); + if(*iter) + _type->renumberValuesOnNodes(arr->getConstPointer(),*iter); setMesh(meshC2); return true; } +/*! + * This method applyies ParaMEDMEM::MEDCouplingPointSet::zipCoords method on 'this->_mesh' that should be set and of type ParaMEDMEM::MEDCouplingPointSet. + * If some nodes have disappeared true is returned. + */ +bool MEDCouplingFieldDouble::zipCoords() throw(INTERP_KERNEL::Exception) +{ + const MEDCouplingPointSet *meshC=dynamic_cast(_mesh); + if(!meshC) + throw INTERP_KERNEL::Exception("MEDCouplingFieldDouble::zipCoords : Invalid support mesh to apply zipCoords on it : must be a MEDCouplingPointSet one !"); + MEDCouplingAutoRefCountObjectPtr meshC2((MEDCouplingPointSet *)meshC->deepCpy()); + int oldNbOfNodes=meshC2->getNumberOfNodes(); + MEDCouplingAutoRefCountObjectPtr arr=meshC2->zipCoordsTraducer(); + if(meshC2->getNumberOfNodes()!=oldNbOfNodes) + { + std::vector arrays; + _time_discr->getArrays(arrays); + for(std::vector::const_iterator iter=arrays.begin();iter!=arrays.end();iter++) + if(*iter) + _type->renumberValuesOnNodes(arr->getConstPointer(),*iter); + setMesh(meshC2); + return true; + } + return false; +} + +/*! + * This method applyies ParaMEDMEM::MEDCouplingUMesh::zipConnectivityTraducer on 'this->_mesh' that should be set and of type ParaMEDMEM::MEDCouplingUMesh. + * The semantic of 'compType' is given in ParaMEDMEM::MEDCouplingUMesh::zipConnectivityTraducer method. + */ +bool MEDCouplingFieldDouble::zipConnectivity(int compType) throw(INTERP_KERNEL::Exception) +{ + const MEDCouplingUMesh *meshC=dynamic_cast(_mesh); + if(!meshC) + throw INTERP_KERNEL::Exception("MEDCouplingFieldDouble::zipCoords : Invalid support mesh to apply zipCoords on it : must be a MEDCouplingPointSet one !"); + MEDCouplingAutoRefCountObjectPtr meshC2((MEDCouplingUMesh *)meshC->deepCpy()); + int oldNbOfCells=meshC2->getNumberOfCells(); + MEDCouplingAutoRefCountObjectPtr arr=meshC2->zipConnectivityTraducer(compType); + if(meshC2->getNumberOfCells()!=oldNbOfCells) + { + std::vector arrays; + _time_discr->getArrays(arrays); + for(std::vector::const_iterator iter=arrays.begin();iter!=arrays.end();iter++) + if(*iter) + _type->renumberValuesOnCells(meshC,arr->getConstPointer(),*iter); + setMesh(meshC2); + return true; + } + return false; +} + MEDCouplingFieldDouble *MEDCouplingFieldDouble::doublyContractedProduct() const throw(INTERP_KERNEL::Exception) { MEDCouplingTimeDiscretization *td=_time_discr->doublyContractedProduct(); diff --git a/src/MEDCoupling/MEDCouplingFieldDouble.hxx b/src/MEDCoupling/MEDCouplingFieldDouble.hxx index cbc0cf924..bcdb5861d 100644 --- a/src/MEDCoupling/MEDCouplingFieldDouble.hxx +++ b/src/MEDCoupling/MEDCouplingFieldDouble.hxx @@ -69,7 +69,9 @@ namespace ParaMEDMEM double accumulate(int compId) const; void accumulate(double *res) const; double getMaxValue() const throw(INTERP_KERNEL::Exception); + double getMaxValue2(DataArrayInt*& tupleIds) const throw(INTERP_KERNEL::Exception); double getMinValue() const throw(INTERP_KERNEL::Exception); + double getMinValue2(DataArrayInt*& tupleIds) const throw(INTERP_KERNEL::Exception); double getAverageValue() const throw(INTERP_KERNEL::Exception); double getWeightedAverageValue() const throw(INTERP_KERNEL::Exception); double normL1(int compId) const throw(INTERP_KERNEL::Exception); @@ -83,6 +85,9 @@ namespace ParaMEDMEM void getValueOn(const double *spaceLoc, double time, double *res) const throw(INTERP_KERNEL::Exception); //! \b temporary void applyLin(double a, double b, int compoId); + MEDCouplingFieldDouble &operator=(double value) throw(INTERP_KERNEL::Exception); + void fillFromAnalytic(int nbOfComp, FunctionToEvaluate func) throw(INTERP_KERNEL::Exception); + void fillFromAnalytic(int nbOfComp, const char *func) throw(INTERP_KERNEL::Exception); void applyFunc(int nbOfComp, FunctionToEvaluate func); void applyFunc(int nbOfComp, const char *func); void applyFunc(const char *func); @@ -103,6 +108,8 @@ namespace ParaMEDMEM void changeUnderlyingMesh(const MEDCouplingMesh *other, int levOfCheck, double prec) throw(INTERP_KERNEL::Exception); void substractInPlaceDM(const MEDCouplingFieldDouble *f, int levOfCheck, double prec) throw(INTERP_KERNEL::Exception); bool mergeNodes(double eps) throw(INTERP_KERNEL::Exception); + bool zipCoords() throw(INTERP_KERNEL::Exception); + bool zipConnectivity(int compType) 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); diff --git a/src/MEDCoupling/MEDCouplingMemArray.cxx b/src/MEDCoupling/MEDCouplingMemArray.cxx index 7ced3782b..c40c4dd92 100644 --- a/src/MEDCoupling/MEDCouplingMemArray.cxx +++ b/src/MEDCoupling/MEDCouplingMemArray.cxx @@ -116,6 +116,13 @@ void DataArrayDouble::alloc(int nbOfTuple, int nbOfCompo) void DataArrayDouble::fillWithZero() { _mem.fillWithValue(0.); + declareAsNew(); +} + +void DataArrayDouble::fillWithValue(double val) +{ + _mem.fillWithValue(val); + declareAsNew(); } std::string DataArrayDouble::repr() const @@ -206,6 +213,23 @@ void DataArrayDouble::renumberInPlace(const int *old2New) declareAsNew(); } +/*! + * This method does \b not change the number of tuples after this call. + * Only a permutation is done. + */ +void DataArrayDouble::renumberInPlaceR(const int *new2Old) +{ + int nbTuples=getNumberOfTuples(); + int nbOfCompo=getNumberOfComponents(); + double *tmp=new double[nbTuples*nbOfCompo]; + const double *iptr=getConstPointer(); + for(int i=0;igetPointer(); for(int i=0;icopyStringInfoFrom(*this); + return ret; +} + +/*! + * This method does \b not change the number of tuples after this call. + * Only a permutation is done. + */ +DataArrayDouble *DataArrayDouble::renumberR(const int *new2Old) const +{ + int nbTuples=getNumberOfTuples(); + int nbOfCompo=getNumberOfComponents(); + DataArrayDouble *ret=DataArrayDouble::New(); + ret->alloc(nbTuples,nbOfCompo); + ret->copyStringInfoFrom(*this); + const double *iptr=getConstPointer(); + double *optr=ret->getPointer(); + for(int i=0;icopyStringInfoFrom(*this); + return ret; +} + +/*! + * Idem DataArrayDouble::renumber method except that the number of tuples is reduced. + * That is to say that it is expected that newNbOfTuplegetNumberOfTuples(). + * ['old2New','old2New'+getNumberOfTuples()) defines a range containing old to new array. For every negative value in ['old2NewBg','old2New'+getNumberOfTuples()) the corresponding tuple is + * omitted. + */ +DataArrayDouble *DataArrayDouble::renumberAndReduce(const int *old2New, int newNbOfTuple) const +{ + int nbTuples=getNumberOfTuples(); + int nbOfCompo=getNumberOfComponents(); + DataArrayDouble *ret=DataArrayDouble::New(); + ret->alloc(newNbOfTuple,nbOfCompo); + const double *iptr=getConstPointer(); + double *optr=ret->getPointer(); + for(int i=0;i=0) + std::copy(iptr+i*nbOfCompo,iptr+(i+1)*nbOfCompo,optr+w*nbOfCompo); + } + ret->copyStringInfoFrom(*this); + return ret; +} + +/*! + * This method is a generalization of DataArrayDouble::substr method because a not contigous range can be specified here. + * This method is equavalent to DataArrayDouble::renumberAndReduce except that convention in input is new2old and \b not old2new. + */ +DataArrayDouble *DataArrayDouble::selectByTupleId(const int *new2OldBg, const int *new2OldEnd) const +{ + DataArrayDouble *ret=DataArrayDouble::New(); + int nbComp=getNumberOfComponents(); + ret->alloc(std::distance(new2OldBg,new2OldEnd),nbComp); + ret->copyStringInfoFrom(*this); + double *pt=ret->getPointer(); + const double *srcPt=getConstPointer(); + int i=0; + for(const int *w=new2OldBg;w!=new2OldEnd;w++,i++) + std::copy(srcPt+(*w)*nbComp,srcPt+((*w)+1)*nbComp,pt+i*nbComp); + ret->copyStringInfoFrom(*this); return ret; } @@ -281,23 +368,6 @@ DataArrayDouble *DataArrayDouble::changeNbOfComponents(int newNbOfComp, double d return ret; } -/*! - * This method is a generalization of DataArrayDouble::substr method because a not contigous range can be specified here. - */ -DataArrayDouble *DataArrayDouble::selectByTupleId(const int *start, const int *end) const -{ - DataArrayDouble *ret=DataArrayDouble::New(); - int nbComp=getNumberOfComponents(); - ret->alloc(std::distance(start,end),nbComp); - ret->copyStringInfoFrom(*this); - double *pt=ret->getPointer(); - const double *srcPt=getConstPointer(); - int i=0; - for(const int *w=start;w!=end;w++,i++) - std::copy(srcPt+(*w)*nbComp,srcPt+((*w)+1)*nbComp,pt+i*nbComp); - return ret; -} - void DataArrayDouble::setArrayIn(DataArrayDouble *newArray, DataArrayDouble* &arrayToSet) { if(newArray!=arrayToSet) @@ -340,6 +410,15 @@ double DataArrayDouble::getMaxValue(int& tupleId) const throw(INTERP_KERNEL::Exc return *loc; } +double DataArrayDouble::getMaxValue2(DataArrayInt*& tupleIds) const throw(INTERP_KERNEL::Exception) +{ + int tmp; + tupleIds=0; + double ret=getMaxValue(tmp); + tupleIds=getIdsInRange(ret,ret); + return ret; +} + double DataArrayDouble::getMinValue(int& tupleId) const throw(INTERP_KERNEL::Exception) { if(getNumberOfComponents()!=1) @@ -353,6 +432,15 @@ double DataArrayDouble::getMinValue(int& tupleId) const throw(INTERP_KERNEL::Exc return *loc; } +double DataArrayDouble::getMinValue2(DataArrayInt*& tupleIds) const throw(INTERP_KERNEL::Exception) +{ + int tmp; + tupleIds=0; + double ret=getMinValue(tmp); + tupleIds=getIdsInRange(ret,ret); + return ret; +} + double DataArrayDouble::getAverageValue() const throw(INTERP_KERNEL::Exception) { if(getNumberOfComponents()!=1) @@ -1044,6 +1132,13 @@ void DataArrayInt::alloc(int nbOfTuple, int nbOfCompo) void DataArrayInt::fillWithZero() { _mem.fillWithValue(0); + declareAsNew(); +} + +void DataArrayInt::fillWithValue(int val) +{ + _mem.fillWithValue(val); + declareAsNew(); } std::string DataArrayInt::repr() const @@ -1095,7 +1190,7 @@ void DataArrayInt::transformWithIndArr(const int *indArr) } /*! - * This method invert array 'di' that is a conversion map from Old to New node numbering to New to Old node numbering. + * This method invert array 'di' that is a conversion map from Old to New numbering to New to Old numbering. */ DataArrayInt *DataArrayInt::invertArrayO2N2N2O(int newNbOfElem) const { @@ -1110,6 +1205,22 @@ DataArrayInt *DataArrayInt::invertArrayO2N2N2O(int newNbOfElem) const return ret; } +/*! + * This method invert array 'di' that is a conversion map from New to old numbering to Old to New numbering. + */ +DataArrayInt *DataArrayInt::invertArrayN2O2O2N(int oldNbOfElem) const +{ + DataArrayInt *ret=DataArrayInt::New(); + ret->alloc(oldNbOfElem,1); + const int *new2Old=getConstPointer(); + int *pt=ret->getPointer(); + std::fill(pt,pt+oldNbOfElem,-1); + int nbOfNewElems=getNumberOfTuples(); + for(int i=0;igetPointer(); for(int i=0;icopyStringInfoFrom(*this); + return ret; +} + +DataArrayInt *DataArrayInt::renumberR(const int *new2Old) const +{ + int nbTuples=getNumberOfTuples(); + int nbOfCompo=getNumberOfComponents(); + DataArrayInt *ret=DataArrayInt::New(); + ret->alloc(nbTuples,nbOfCompo); + ret->copyStringInfoFrom(*this); + const int *iptr=getConstPointer(); + int *optr=ret->getPointer(); + for(int i=0;icopyStringInfoFrom(*this); + return ret; +} + +/*! + * Idem DataArrayDouble::renumber method except that the number of tuples is reduced. + * That is to say that it is expected that newNbOfTuplegetNumberOfTuples(). + * ['old2New','old2New'+getNumberOfTuples()) defines a range containing old to new array. For every negative value in ['old2NewBg','old2New'getNumberOfTuples()) the corresponding tuple is + * omitted. + */ +DataArrayInt *DataArrayInt::renumberAndReduce(const int *old2New, int newNbOfTuple) const +{ + int nbTuples=getNumberOfTuples(); + int nbOfCompo=getNumberOfComponents(); + DataArrayInt *ret=DataArrayInt::New(); + ret->alloc(newNbOfTuple,nbOfCompo); + const int *iptr=getConstPointer(); + int *optr=ret->getPointer(); + for(int i=0;i=0) + std::copy(iptr+i*nbOfCompo,iptr+(i+1)*nbOfCompo,optr+w*nbOfCompo); + } + ret->copyStringInfoFrom(*this); + return ret; +} + +/*! + * This method is a generalization of DataArrayDouble::substr method because a not contigous range can be specified here. + * This method is equavalent to DataArrayInt::renumberAndReduce except that convention in input is new2old and \b not old2new. + */ +DataArrayInt *DataArrayInt::selectByTupleId(const int *new2OldBg, const int *new2OldEnd) const +{ + DataArrayInt *ret=DataArrayInt::New(); + int nbComp=getNumberOfComponents(); + ret->alloc(std::distance(new2OldBg,new2OldEnd),nbComp); + ret->copyStringInfoFrom(*this); + int *pt=ret->getPointer(); + const int *srcPt=getConstPointer(); + int i=0; + for(const int *w=new2OldBg;w!=new2OldEnd;w++,i++) + std::copy(srcPt+(*w)*nbComp,srcPt+((*w)+1)*nbComp,pt+i*nbComp); + ret->copyStringInfoFrom(*this); return ret; } @@ -1243,24 +1426,6 @@ DataArrayInt *DataArrayInt::changeNbOfComponents(int newNbOfComp, int dftValue) return ret; } - -/*! - * This method is a generalization of DataArrayDouble::substr method because a not contigous range can be specified here. - */ -DataArrayInt *DataArrayInt::selectByTupleId(const int *start, const int *end) const -{ - DataArrayInt *ret=DataArrayInt::New(); - int nbComp=getNumberOfComponents(); - ret->alloc(std::distance(start,end),nbComp); - ret->copyStringInfoFrom(*this); - int *pt=ret->getPointer(); - const int *srcPt=getConstPointer(); - int i=0; - for(const int *w=start;w!=end;w++,i++) - std::copy(srcPt+(*w)*nbComp,srcPt+((*w)+1)*nbComp,pt+i*nbComp); - return ret; -} - void DataArrayInt::reAlloc(int nbOfTuples) { _mem.reAlloc(_info_on_compo.size()*nbOfTuples); diff --git a/src/MEDCoupling/MEDCouplingMemArray.hxx b/src/MEDCoupling/MEDCouplingMemArray.hxx index 33b8896b6..c866a80b3 100644 --- a/src/MEDCoupling/MEDCouplingMemArray.hxx +++ b/src/MEDCoupling/MEDCouplingMemArray.hxx @@ -115,6 +115,7 @@ namespace ParaMEDMEM MEDCOUPLING_EXPORT DataArrayDouble *performCpy(bool deepCpy) const; MEDCOUPLING_EXPORT void alloc(int nbOfTuple, int nbOfCompo); MEDCOUPLING_EXPORT void fillWithZero(); + MEDCOUPLING_EXPORT void fillWithValue(double val); MEDCOUPLING_EXPORT std::string repr() const; MEDCOUPLING_EXPORT std::string reprZip() const; MEDCOUPLING_EXPORT void reprStream(std::ostream& stream) const; @@ -127,10 +128,13 @@ namespace ParaMEDMEM MEDCOUPLING_EXPORT void reAlloc(int nbOfTuples); MEDCOUPLING_EXPORT DataArrayInt *convertToIntArr() const; MEDCOUPLING_EXPORT void renumberInPlace(const int *old2New); + MEDCOUPLING_EXPORT void renumberInPlaceR(const int *new2Old); MEDCOUPLING_EXPORT DataArrayDouble *renumber(const int *old2New) const; + MEDCOUPLING_EXPORT DataArrayDouble *renumberR(const int *new2Old) const; + MEDCOUPLING_EXPORT DataArrayDouble *renumberAndReduce(const int *old2New, int newNbOfTuple) const; + MEDCOUPLING_EXPORT DataArrayDouble *selectByTupleId(const int *new2OldBg, const int *new2OldEnd) const; MEDCOUPLING_EXPORT DataArrayDouble *substr(int tupleIdBg, int tupleIdEnd=-1) const throw(INTERP_KERNEL::Exception); MEDCOUPLING_EXPORT DataArrayDouble *changeNbOfComponents(int newNbOfComp, double dftValue) const throw(INTERP_KERNEL::Exception); - MEDCOUPLING_EXPORT DataArrayDouble *selectByTupleId(const int *start, const int *end) const; MEDCOUPLING_EXPORT void getTuple(int tupleId, double *res) const { std::copy(_mem.getConstPointerLoc(tupleId*_info_on_compo.size()),_mem.getConstPointerLoc((tupleId+1)*_info_on_compo.size()),res); } MEDCOUPLING_EXPORT double getIJ(int tupleId, int compoId) const { return _mem[tupleId*_info_on_compo.size()+compoId]; } MEDCOUPLING_EXPORT void setIJ(int tupleId, int compoId, double newVal) { _mem[tupleId*_info_on_compo.size()+compoId]=newVal; declareAsNew(); } @@ -142,6 +146,8 @@ namespace ParaMEDMEM MEDCOUPLING_EXPORT void checkNoNullValues() const throw(INTERP_KERNEL::Exception); MEDCOUPLING_EXPORT double getMaxValue(int& tupleId) const throw(INTERP_KERNEL::Exception); MEDCOUPLING_EXPORT double getMinValue(int& tupleId) const throw(INTERP_KERNEL::Exception); + MEDCOUPLING_EXPORT double getMaxValue2(DataArrayInt*& tupleIds) const throw(INTERP_KERNEL::Exception); + MEDCOUPLING_EXPORT double getMinValue2(DataArrayInt*& tupleIds) const throw(INTERP_KERNEL::Exception); MEDCOUPLING_EXPORT double getAverageValue() const throw(INTERP_KERNEL::Exception); MEDCOUPLING_EXPORT void accumulate(double *res) const; MEDCOUPLING_EXPORT double accumulate(int compId) const; @@ -193,6 +199,7 @@ namespace ParaMEDMEM MEDCOUPLING_EXPORT bool isEqual(const DataArrayInt& other) const; MEDCOUPLING_EXPORT bool isEqualWithoutConsideringStr(const DataArrayInt& other) const; MEDCOUPLING_EXPORT void fillWithZero(); + MEDCOUPLING_EXPORT void fillWithValue(int val); MEDCOUPLING_EXPORT std::string repr() const; MEDCOUPLING_EXPORT std::string reprZip() const; MEDCOUPLING_EXPORT void reprStream(std::ostream& stream) const; @@ -201,15 +208,19 @@ namespace ParaMEDMEM MEDCOUPLING_EXPORT void reprZipWithoutNameStream(std::ostream& stream) const; MEDCOUPLING_EXPORT void transformWithIndArr(const int *indArr); MEDCOUPLING_EXPORT DataArrayInt *invertArrayO2N2N2O(int newNbOfElem) const; + MEDCOUPLING_EXPORT DataArrayInt *invertArrayN2O2O2N(int oldNbOfElem) const; //!alloc or useArray should have been called before. MEDCOUPLING_EXPORT void reAlloc(int nbOfTuples); MEDCOUPLING_EXPORT DataArrayDouble *convertToDblArr() const; MEDCOUPLING_EXPORT void renumberInPlace(const int *old2New); + MEDCOUPLING_EXPORT void renumberInPlaceR(const int *new2Old); MEDCOUPLING_EXPORT DataArrayInt *renumber(const int *old2New) const; + MEDCOUPLING_EXPORT DataArrayInt *renumberR(const int *new2Old) const; + MEDCOUPLING_EXPORT DataArrayInt *renumberAndReduce(const int *old2NewBg, int newNbOfTuple) const; + MEDCOUPLING_EXPORT DataArrayInt *selectByTupleId(const int *new2OldBg, const int *new2OldEnd) const; MEDCOUPLING_EXPORT bool isIdentity() const; MEDCOUPLING_EXPORT DataArrayInt *substr(int tupleIdBg, int tupleIdEnd=-1) const throw(INTERP_KERNEL::Exception); MEDCOUPLING_EXPORT DataArrayInt *changeNbOfComponents(int newNbOfComp, int dftValue) const throw(INTERP_KERNEL::Exception); - MEDCOUPLING_EXPORT DataArrayInt *selectByTupleId(const int *start, const int *end) const; MEDCOUPLING_EXPORT void getTuple(int tupleId, int *res) const { std::copy(_mem.getConstPointerLoc(tupleId*_info_on_compo.size()),_mem.getConstPointerLoc((tupleId+1)*_info_on_compo.size()),res); } MEDCOUPLING_EXPORT int getIJ(int tupleId, int compoId) const { return _mem[tupleId*_info_on_compo.size()+compoId]; } MEDCOUPLING_EXPORT void setIJ(int tupleId, int compoId, int newVal) { _mem[tupleId*_info_on_compo.size()+compoId]=newVal; } diff --git a/src/MEDCoupling/MEDCouplingMesh.cxx b/src/MEDCoupling/MEDCouplingMesh.cxx index 5ad1928d3..cd3157568 100644 --- a/src/MEDCoupling/MEDCouplingMesh.cxx +++ b/src/MEDCoupling/MEDCouplingMesh.cxx @@ -21,9 +21,9 @@ #include "MEDCouplingMemArray.hxx" #include "MEDCouplingFieldDouble.hxx" #include "MEDCouplingFieldDiscretization.hxx" +#include "MEDCouplingAutoRefCountObjectPtr.hxx" -#include "InterpKernelExprParser.hxx" - +#include #include #include @@ -169,32 +169,10 @@ bool MEDCouplingMesh::areCompatibleForMerge(const MEDCouplingMesh *other) const */ MEDCouplingFieldDouble *MEDCouplingMesh::fillFromAnalytic(TypeOfField t, int nbOfComp, FunctionToEvaluate func) const { - MEDCouplingFieldDouble *ret=MEDCouplingFieldDouble::New(t); + MEDCouplingAutoRefCountObjectPtr ret=MEDCouplingFieldDouble::New(t,NO_TIME); ret->setMesh(this); - DataArrayDouble *loc=ret->getDiscretization()->getLocalizationOfDiscValues(this); - DataArrayDouble *array=DataArrayDouble::New(); - int nbOfTuple=loc->getNumberOfTuples(); - int nbCompIn=loc->getNumberOfComponents(); - const double *locPtr=loc->getConstPointer(); - array->alloc(nbOfTuple,nbOfComp); - double *ptToFill=array->getPointer(); - for(int i=0;i(oss,", ")); - oss << ") : Evaluation of function failed !"; - loc->decrRef(); - array->decrRef(); - ret->decrRef(); - throw INTERP_KERNEL::Exception(oss.str().c_str()); - } - ptToFill+=nbOfComp; - } - loc->decrRef(); - ret->setArray(array); - array->decrRef(); + ret->fillFromAnalytic(nbOfComp,func); + ret->incrRef(); return ret; } @@ -219,50 +197,10 @@ void MEDCouplingMesh::copyTinyStringsFrom(const MEDCouplingMesh *other) throw(IN */ MEDCouplingFieldDouble *MEDCouplingMesh::fillFromAnalytic(TypeOfField t, int nbOfComp, const char *func) const { - INTERP_KERNEL::ExprParser expr(func); - expr.parse(); - std::set vars; - expr.getTrueSetOfVars(vars); - if((int)vars.size()>getSpaceDimension()) - { - std::ostringstream oss; oss << "The mesh has a spaceDim==" << getSpaceDimension() << " and there are "; - oss << vars.size() << " variables : "; - std::copy(vars.begin(),vars.end(),std::ostream_iterator(oss," ")); - throw INTERP_KERNEL::Exception(oss.str().c_str()); - } - std::vector varsV(vars.begin(),vars.end()); - expr.prepareExprEvaluation(varsV); - // - MEDCouplingFieldDouble *ret=MEDCouplingFieldDouble::New(t); + MEDCouplingAutoRefCountObjectPtr ret=MEDCouplingFieldDouble::New(t,NO_TIME); ret->setMesh(this); - DataArrayDouble *loc=ret->getDiscretization()->getLocalizationOfDiscValues(this); - DataArrayDouble *array=DataArrayDouble::New(); - int nbOfTuple=loc->getNumberOfTuples(); - int nbCompIn=loc->getNumberOfComponents(); - const double *locPtr=loc->getConstPointer(); - array->alloc(nbOfTuple,nbOfComp); - double *ptToFill=array->getPointer(); - for(int i=0;i(oss,", ")); - oss << ") : Evaluation of function failed ! " << e.what(); - loc->decrRef(); - array->decrRef(); - ret->decrRef(); - throw INTERP_KERNEL::Exception(oss.str().c_str()); - } - ptToFill+=nbOfComp; - } - loc->decrRef(); - ret->setArray(array); - array->decrRef(); + ret->fillFromAnalytic(nbOfComp,func); + ret->incrRef(); return ret; } diff --git a/src/MEDCoupling/MEDCouplingTimeDiscretization.cxx b/src/MEDCoupling/MEDCouplingTimeDiscretization.cxx index c9c8a41d2..a98a75f58 100644 --- a/src/MEDCoupling/MEDCouplingTimeDiscretization.cxx +++ b/src/MEDCoupling/MEDCouplingTimeDiscretization.cxx @@ -493,6 +493,33 @@ void MEDCouplingTimeDiscretization::sortPerTuple(bool asc) throw(INTERP_KERNEL:: } } +void MEDCouplingTimeDiscretization::setUniformValue(int nbOfTuple, double value) +{ + std::vector arrays; + getArrays(arrays); + std::vector< MEDCouplingAutoRefCountObjectPtr > arrays2(arrays.size()); + for(int j=0;j<(int)arrays.size();j++) + { + if(arrays[j]) + { + arrays[j]->incrRef(); + arrays[j]->fillWithValue(value); + arrays2[j]=arrays[j]; + } + else + { + DataArrayDouble *tmp=DataArrayDouble::New(); + tmp->alloc(nbOfTuple,1); + tmp->fillWithValue(value); + arrays2[j]=tmp; + } + } + std::vector arrays3(arrays.size()); + for(int j=0;j<(int)arrays.size();j++) + arrays3[j]=arrays2[j]; + setArrays(arrays3,0); +} + void MEDCouplingTimeDiscretization::applyLin(double a, double b, int compoId) { std::vector arrays; @@ -580,6 +607,32 @@ void MEDCouplingTimeDiscretization::applyFuncFast64(const char *func) } } +void MEDCouplingTimeDiscretization::fillFromAnalytic(const DataArrayDouble *loc, int nbOfComp, FunctionToEvaluate func) throw(INTERP_KERNEL::Exception) +{ + std::vector arrays; + getArrays(arrays); + std::vector< MEDCouplingAutoRefCountObjectPtr > arrays2(arrays.size()); + for(int j=0;j<(int)arrays.size();j++) + arrays2[j]=loc->applyFunc(nbOfComp,func); + std::vector arrays3(arrays.size()); + for(int j=0;j<(int)arrays.size();j++) + arrays3[j]=arrays2[j]; + setArrays(arrays3,0); +} + +void MEDCouplingTimeDiscretization::fillFromAnalytic(const DataArrayDouble *loc, int nbOfComp, const char *func) throw(INTERP_KERNEL::Exception) +{ + std::vector arrays; + getArrays(arrays); + std::vector< MEDCouplingAutoRefCountObjectPtr > arrays2(arrays.size()); + for(int j=0;j<(int)arrays.size();j++) + arrays2[j]=loc->applyFunc(nbOfComp,func); + std::vector arrays3(arrays.size()); + for(int j=0;j<(int)arrays.size();j++) + arrays3[j]=arrays2[j]; + setArrays(arrays3,0); +} + MEDCouplingNoTimeLabel::MEDCouplingNoTimeLabel() { } diff --git a/src/MEDCoupling/MEDCouplingTimeDiscretization.hxx b/src/MEDCoupling/MEDCouplingTimeDiscretization.hxx index a9f1de097..f3e80dd9b 100644 --- a/src/MEDCoupling/MEDCouplingTimeDiscretization.hxx +++ b/src/MEDCoupling/MEDCouplingTimeDiscretization.hxx @@ -105,13 +105,15 @@ namespace ParaMEDMEM virtual MEDCouplingTimeDiscretization *maxPerTuple() const throw(INTERP_KERNEL::Exception); virtual void changeNbOfComponents(int newNbOfComp, double dftValue) throw(INTERP_KERNEL::Exception); virtual void sortPerTuple(bool asc) throw(INTERP_KERNEL::Exception); + virtual void setUniformValue(int nbOfTuple, double value); virtual void applyLin(double a, double b, int compoId); virtual void applyFunc(int nbOfComp, FunctionToEvaluate func); virtual void applyFunc(int nbOfComp, const char *func); virtual void applyFunc(const char *func); virtual void applyFuncFast32(const char *func); virtual void applyFuncFast64(const char *func); - + virtual void fillFromAnalytic(const DataArrayDouble *loc, int nbOfComp, FunctionToEvaluate func) throw(INTERP_KERNEL::Exception); + virtual void fillFromAnalytic(const DataArrayDouble *loc, int nbOfComp, const char *func) throw(INTERP_KERNEL::Exception); // virtual ~MEDCouplingTimeDiscretization(); protected: diff --git a/src/MEDCoupling/MEDCouplingUMesh.cxx b/src/MEDCoupling/MEDCouplingUMesh.cxx index 4da00a715..11f9d12ea 100644 --- a/src/MEDCoupling/MEDCouplingUMesh.cxx +++ b/src/MEDCoupling/MEDCouplingUMesh.cxx @@ -572,7 +572,9 @@ void MEDCouplingUMesh::convertToPolyTypes(const std::vector& cellIdsToConve DataArrayInt *MEDCouplingUMesh::zipCoordsTraducer() { int nbOfNodes=getNumberOfNodes(); - int *traducer=new int[nbOfNodes]; + DataArrayInt *ret=DataArrayInt::New(); + ret->alloc(nbOfNodes,1); + int *traducer=ret->getPointer(); std::fill(traducer,traducer+nbOfNodes,-1); int nbOfCells=getNumberOfCells(); const int *connIndex=_nodal_connec_index->getConstPointer(); @@ -587,14 +589,7 @@ DataArrayInt *MEDCouplingUMesh::zipCoordsTraducer() for(int j=connIndex[i]+1;j=0) conn[j]=traducer[conn[j]]; - DataArrayInt *ret=DataArrayInt::New(); - ret->alloc(newNbOfNodes,1); - int *retPtr=ret->getPointer(); - for(int i=0;iselectByTupleId(retPtr,retPtr+newNbOfNodes); + DataArrayDouble *newCoords=_coords->renumberAndReduce(traducer,newNbOfNodes); setCoords(newCoords); newCoords->decrRef(); return ret; diff --git a/src/MEDCoupling/Test/MEDCouplingBasicsTest.hxx b/src/MEDCoupling/Test/MEDCouplingBasicsTest.hxx index 8382a9230..0e8cf3e7f 100644 --- a/src/MEDCoupling/Test/MEDCouplingBasicsTest.hxx +++ b/src/MEDCoupling/Test/MEDCouplingBasicsTest.hxx @@ -125,6 +125,22 @@ namespace ParaMEDMEM CPPUNIT_TEST( testIsEqualWithoutConsideringStr1 ); CPPUNIT_TEST( testGetNodeIdsOfCell1 ); CPPUNIT_TEST( testGetEdgeRatioField1 ); + CPPUNIT_TEST( testFillFromAnalytic3 ); + CPPUNIT_TEST( testFieldDoubleOpEqual1 ); + CPPUNIT_TEST( testAreaBary3D2 ); + CPPUNIT_TEST( testGetMeasureFieldCMesh1 ); + CPPUNIT_TEST( testFieldDoubleZipCoords1 ); + CPPUNIT_TEST( testFieldDoubleZipConnectivity1 ); + CPPUNIT_TEST( testDaDoubleRenumber1 ); + CPPUNIT_TEST( testDaDoubleRenumberAndReduce1 ); + CPPUNIT_TEST( testDaDoubleRenumberInPlace1 ); + CPPUNIT_TEST( testDaDoubleSelectByTupleId1 ); + CPPUNIT_TEST( testDaDoubleRenumberR1 ); + CPPUNIT_TEST( testDaDoubleRenumberInPlaceR1 ); + CPPUNIT_TEST( testDaDoubleGetMinMaxValues1 ); + CPPUNIT_TEST( testFieldDoubleGetMinMaxValues2 ); + CPPUNIT_TEST( testBuildUnstructuredCMesh1 ); + CPPUNIT_TEST( testDataArrayIntInvertO2NNO21 ); //MEDCouplingBasicsTestInterp.cxx CPPUNIT_TEST( test2DInterpP0P0_1 ); CPPUNIT_TEST( test2DInterpP0P0PL_1 ); @@ -278,6 +294,22 @@ namespace ParaMEDMEM void testIsEqualWithoutConsideringStr1(); void testGetNodeIdsOfCell1(); void testGetEdgeRatioField1(); + void testFillFromAnalytic3(); + void testFieldDoubleOpEqual1(); + void testAreaBary3D2(); + void testGetMeasureFieldCMesh1(); + void testFieldDoubleZipCoords1(); + void testFieldDoubleZipConnectivity1(); + void testDaDoubleRenumber1(); + void testDaDoubleRenumberAndReduce1(); + void testDaDoubleRenumberInPlace1(); + void testDaDoubleSelectByTupleId1(); + void testDaDoubleRenumberR1(); + void testDaDoubleRenumberInPlaceR1(); + void testDaDoubleGetMinMaxValues1(); + void testFieldDoubleGetMinMaxValues2(); + void testBuildUnstructuredCMesh1(); + void testDataArrayIntInvertO2NNO21(); //MEDCouplingBasicsTestInterp.cxx void test2DInterpP0P0_1(); void test2DInterpP0P0PL_1(); diff --git a/src/MEDCoupling/Test/MEDCouplingBasicsTest1.cxx b/src/MEDCoupling/Test/MEDCouplingBasicsTest1.cxx index 5c34f02c8..ffa8b6a75 100644 --- a/src/MEDCoupling/Test/MEDCouplingBasicsTest1.cxx +++ b/src/MEDCoupling/Test/MEDCouplingBasicsTest1.cxx @@ -691,8 +691,8 @@ void MEDCouplingBasicsTest::testZipCoords() MEDCouplingUMesh *subMesh=dynamic_cast(subMeshPtSet); CPPUNIT_ASSERT(subMesh); DataArrayInt *traducer=subMesh->zipCoordsTraducer(); - const int expectedTraducer[7]={0,1,3,4,5,7,8}; - CPPUNIT_ASSERT(std::equal(expectedTraducer,expectedTraducer+7,traducer->getPointer())); + const int expectedTraducer[9]={0,1,-1,2,3,4,-1,5,6}; + CPPUNIT_ASSERT(std::equal(expectedTraducer,expectedTraducer+9,traducer->getPointer())); traducer->decrRef(); CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_QUAD4,*subMesh->getAllTypes().begin()); CPPUNIT_ASSERT_EQUAL(2,subMesh->getNumberOfCells()); diff --git a/src/MEDCoupling/Test/MEDCouplingBasicsTest2.cxx b/src/MEDCoupling/Test/MEDCouplingBasicsTest2.cxx index f636313cf..174d0935c 100644 --- a/src/MEDCoupling/Test/MEDCouplingBasicsTest2.cxx +++ b/src/MEDCoupling/Test/MEDCouplingBasicsTest2.cxx @@ -2002,3 +2002,843 @@ void MEDCouplingBasicsTest::testGetEdgeRatioField1() f1->decrRef(); m1->decrRef(); } + +void MEDCouplingBasicsTest::testFillFromAnalytic3() +{ + MEDCouplingUMesh *m=build2DTargetMesh_1(); + MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME); + CPPUNIT_ASSERT_THROW(f1->fillFromAnalytic(1,"y+x"),INTERP_KERNEL::Exception); + f1->setMesh(m); + f1->setName("myField"); + f1->fillFromAnalytic(1,"y+x"); + f1->checkCoherency(); + CPPUNIT_ASSERT(std::string(f1->getName())=="myField"); + CPPUNIT_ASSERT(f1->getTypeOfField()==ON_CELLS); + CPPUNIT_ASSERT(f1->getTimeDiscretization()==ONE_TIME); + CPPUNIT_ASSERT_EQUAL(1,f1->getNumberOfComponents()); + CPPUNIT_ASSERT_EQUAL(5,f1->getNumberOfTuples()); + double values1[5]={-0.1,0.23333333333333336,0.56666666666666665,0.4,0.9}; + const double *tmp=f1->getArray()->getConstPointer(); + std::transform(tmp,tmp+5,values1,values1,std::minus()); + std::transform(values1,values1+5,values1,std::ptr_fun(fabs)); + double max=*std::max_element(values1,values1+5); + CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,max,1.e-12); + f1->decrRef(); + // + f1=MEDCouplingFieldDouble::New(ON_NODES,CONST_ON_TIME_INTERVAL); + f1->setMesh(m); + f1->setEndTime(1.2,3,4); + f1->fillFromAnalytic(1,"y+2*x"); + f1->checkCoherency(); + CPPUNIT_ASSERT(f1->getTypeOfField()==ON_NODES); + CPPUNIT_ASSERT(f1->getTimeDiscretization()==CONST_ON_TIME_INTERVAL); + CPPUNIT_ASSERT_EQUAL(1,f1->getNumberOfComponents()); + CPPUNIT_ASSERT_EQUAL(9,f1->getNumberOfTuples()); + double values2[9]={-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1}; + tmp=f1->getArray()->getConstPointer(); + std::transform(tmp,tmp+9,values2,values2,std::minus()); + std::transform(values2,values2+9,values2,std::ptr_fun(fabs)); + max=*std::max_element(values2,values2+9); + CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,max,1.e-12); + f1->decrRef(); + f1=MEDCouplingFieldDouble::New(ON_NODES,LINEAR_TIME); + f1->setMesh(m); + f1->setEndTime(1.2,3,4); + f1->fillFromAnalytic(1,"2.*x+y"); + f1->checkCoherency(); + CPPUNIT_ASSERT(f1->getTypeOfField()==ON_NODES); + CPPUNIT_ASSERT(f1->getTimeDiscretization()==LINEAR_TIME); + CPPUNIT_ASSERT_EQUAL(1,f1->getNumberOfComponents()); + CPPUNIT_ASSERT_EQUAL(9,f1->getNumberOfTuples()); + tmp=f1->getArray()->getConstPointer(); + double values2Bis[9]={-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1}; + double values2BisBis[9]; + std::transform(tmp,tmp+9,values2Bis,values2BisBis,std::minus()); + std::transform(values2,values2+9,values2BisBis,std::ptr_fun(fabs)); + max=*std::max_element(values2BisBis,values2BisBis+9); + CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,max,1.e-12); + tmp=f1->getEndArray()->getConstPointer(); + std::transform(tmp,tmp+9,values2Bis,values2BisBis,std::minus()); + std::transform(values2,values2+9,values2BisBis,std::ptr_fun(fabs)); + max=*std::max_element(values2BisBis,values2BisBis+9); + CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,max,1.e-12); + f1->decrRef(); + // + f1=MEDCouplingFieldDouble::New(ON_NODES,NO_TIME); + f1->setMesh(m); + f1->fillFromAnalytic(2,"(x+y)*IVec+2*(x+y)*JVec"); + f1->checkCoherency(); + CPPUNIT_ASSERT(f1->getTypeOfField()==ON_NODES); + CPPUNIT_ASSERT(f1->getTimeDiscretization()==NO_TIME); + CPPUNIT_ASSERT_EQUAL(2,f1->getNumberOfComponents()); + CPPUNIT_ASSERT_EQUAL(9,f1->getNumberOfTuples()); + double values3[18]={-0.6,-1.2,-0.1,-0.2,0.4,0.8,-0.1,-0.2,0.4,0.8,0.9,1.8,0.4,0.8,0.9,1.8,1.4,2.8}; + tmp=f1->getArray()->getConstPointer(); + std::transform(tmp,tmp+18,values3,values3,std::minus()); + std::transform(values3,values3+18,values3,std::ptr_fun(fabs)); + max=*std::max_element(values3,values3+18); + CPPUNIT_ASSERT_DOUBLES_EQUAL(0.,max,1.e-12); + double values4[2]; + f1->accumulate(values4); + CPPUNIT_ASSERT_DOUBLES_EQUAL(3.6,values4[0],1.e-12); + CPPUNIT_ASSERT_DOUBLES_EQUAL(7.2,values4[1],1.e-12); + f1->integral(true,values4); + CPPUNIT_ASSERT_DOUBLES_EQUAL(0.5,values4[0],1.e-12); + CPPUNIT_ASSERT_DOUBLES_EQUAL(1.,values4[1],1.e-12); + f1->decrRef(); + // + f1=MEDCouplingFieldDouble::New(ON_NODES,NO_TIME); + f1->setMesh(m); + CPPUNIT_ASSERT_THROW(f1->fillFromAnalytic(1,"1./(x-0.2)"),INTERP_KERNEL::Exception); + // + m->decrRef(); + f1->decrRef(); +} + +void MEDCouplingBasicsTest::testFieldDoubleOpEqual1() +{ + MEDCouplingUMesh *m=build2DTargetMesh_1(); + MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME); + CPPUNIT_ASSERT_THROW((*f1)=0.07,INTERP_KERNEL::Exception); + f1->setMesh(m); + (*f1)=0.07; + f1->checkCoherency(); + CPPUNIT_ASSERT_EQUAL(1,f1->getNumberOfComponents()); + CPPUNIT_ASSERT_EQUAL(5,f1->getNumberOfTuples()); + for(int i=0;i<5;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(0.07,f1->getIJ(i,0),1e-16); + (*f1)=0.09; + f1->checkCoherency(); + CPPUNIT_ASSERT_EQUAL(1,f1->getNumberOfComponents()); + CPPUNIT_ASSERT_EQUAL(5,f1->getNumberOfTuples()); + for(int i=0;i<5;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(0.09,f1->getIJ(i,0),1e-16); + f1->decrRef(); + // + f1=MEDCouplingFieldDouble::New(ON_NODES,LINEAR_TIME); + f1->setEndTime(4.5,2,3); + f1->setMesh(m); + (*f1)=0.08; + f1->checkCoherency(); + CPPUNIT_ASSERT_EQUAL(1,f1->getNumberOfComponents()); + CPPUNIT_ASSERT_EQUAL(9,f1->getNumberOfTuples()); + for(int i=0;i<9;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(0.08,f1->getIJ(i,0),1e-16); + CPPUNIT_ASSERT_EQUAL(1,f1->getEndArray()->getNumberOfComponents()); + CPPUNIT_ASSERT_EQUAL(9,f1->getEndArray()->getNumberOfTuples()); + for(int i=0;i<9;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(0.08,f1->getEndArray()->getIJ(i,0),1e-16); + f1->decrRef(); + // + m->decrRef(); +} + +void MEDCouplingBasicsTest::testAreaBary3D2() +{ + const double coordsForHexa8[24]={ + -75.45749305371, 180.95495078401, 39.515472018008, + -9.755591679144, 23.394927935279, 5.108794294848, + 14.337630157832, 61.705351002702, 160.42422501908, + -27.273893776752, 167.567731083961, 192.830034145464, + // + 99.857193154796,264.499264735586,-8.287335493412, + 144.939882761126,156.38626563134,-31.896173894226, + 161.34096835726,182.4654895809,73.832387065572, + 132.680430393685,255.37973247196,96.15235602819 + }; + const double volHexa8=3258520.29637466; + const double baryHexa8[3]={43.925705821778, 155.31893955289, 65.874418109644}; + + const double coordsForPenta6[18]={ + -68.199829618726,178.938498373416,62.608505919588, + 8.461744647847,76.653979804423,165.00018874933, + -27.273893776752,167.567731083961,192.830034145464, + // + 106.586501038965,262.629609408327,13.124533008813, + 155.465082847275,197.414118382622,78.408350795821, + 132.680430393685,255.37973247196,96.15235602819 + }; + const double volPenta6=944849.868507338; + const double baryPenta6[3]={39.631002313543,182.692711783428,106.98540473964}; + + const double coordsForPyra5[15]={ + 132.680430393685,255.37973247196,96.15235602819, + -27.273893776752,167.567731083961,192.830034145464, + 8.461744647847,76.653979804423,165.00018874933, + 155.465082847275,197.414118382622,78.408350795821, + // + -68.199829618726,178.938498373416,62.608505919588 + }; + const double volPyra5=756943.92980254; + const double baryPyra5[3]={29.204294116618,172.540129749156,118.01035951483}; + MEDCouplingUMesh *mesh=MEDCouplingUMesh::New("Bary3D2",3); + DataArrayDouble *coo=DataArrayDouble::New(); + coo->alloc(19,3); + double *tmp=std::copy(coordsForHexa8,coordsForHexa8+24,coo->getPointer()); + tmp=std::copy(coordsForPenta6,coordsForPenta6+18,tmp); + std::copy(coordsForPyra5,coordsForPyra5+15,tmp); + mesh->setCoords(coo); + coo->decrRef(); + // + int tmpConn[8]={0,1,2,3,4,5,6,7}; + mesh->allocateCells(3); + mesh->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,tmpConn); + std::transform(tmpConn,tmpConn+8,tmpConn,std::bind2nd(std::plus(),8)); + mesh->insertNextCell(INTERP_KERNEL::NORM_PENTA6,6,tmpConn); + std::transform(tmpConn,tmpConn+8,tmpConn,std::bind2nd(std::plus(),6)); + mesh->insertNextCell(INTERP_KERNEL::NORM_PYRA5,5,tmpConn); + mesh->finishInsertingCells(); + mesh->checkCoherency(); + bool isMerged; + int newNebOfNodes; + DataArrayInt *da=mesh->mergeNodes(1e-7,isMerged,newNebOfNodes); + da->decrRef(); + CPPUNIT_ASSERT_EQUAL(12,newNebOfNodes); + MEDCouplingFieldDouble *vols=mesh->getMeasureField(true); + CPPUNIT_ASSERT_EQUAL(3,vols->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(1,vols->getNumberOfComponents()); + CPPUNIT_ASSERT_DOUBLES_EQUAL(volHexa8,vols->getIJ(0,0),1e-6); + CPPUNIT_ASSERT_DOUBLES_EQUAL(volPenta6,vols->getIJ(1,0),1e-7); + CPPUNIT_ASSERT_DOUBLES_EQUAL(volPyra5,vols->getIJ(2,0),1e-7); + vols->decrRef(); + DataArrayDouble *bary=mesh->getBarycenterAndOwner(); + CPPUNIT_ASSERT_EQUAL(3,bary->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(3,bary->getNumberOfComponents()); + CPPUNIT_ASSERT_DOUBLES_EQUAL(baryHexa8[0],bary->getIJ(0,0),1e-11); + CPPUNIT_ASSERT_DOUBLES_EQUAL(baryHexa8[1],bary->getIJ(0,1),1e-11); + CPPUNIT_ASSERT_DOUBLES_EQUAL(baryHexa8[2],bary->getIJ(0,2),1e-11); + CPPUNIT_ASSERT_DOUBLES_EQUAL(baryPenta6[0],bary->getIJ(1,0),1e-11); + CPPUNIT_ASSERT_DOUBLES_EQUAL(baryPenta6[1],bary->getIJ(1,1),1e-11); + CPPUNIT_ASSERT_DOUBLES_EQUAL(baryPenta6[2],bary->getIJ(1,2),1e-11); + CPPUNIT_ASSERT_DOUBLES_EQUAL(baryPyra5[0],bary->getIJ(2,0),1e-11); + CPPUNIT_ASSERT_DOUBLES_EQUAL(baryPyra5[1],bary->getIJ(2,1),1e-11); + CPPUNIT_ASSERT_DOUBLES_EQUAL(baryPyra5[2],bary->getIJ(2,2),1e-11); + bary->decrRef(); + // + mesh->decrRef(); +} + +void MEDCouplingBasicsTest::testGetMeasureFieldCMesh1() +{ + MEDCouplingCMesh *m=MEDCouplingCMesh::New(); + DataArrayDouble *da=DataArrayDouble::New(); + const double discX[4]={2.3,3.4,5.8,10.2}; + const double discY[3]={12.3,23.4,45.8}; + const double discZ[5]={-0.7,1.2,1.25,2.13,2.67}; + da->alloc(4,1); + std::copy(discX,discX+4,da->getPointer()); + m->setCoordsAt(0,da); + da->decrRef(); + m->checkCoherency(); + CPPUNIT_ASSERT_EQUAL(4,m->getNumberOfNodes()); + CPPUNIT_ASSERT_EQUAL(3,m->getNumberOfCells()); + CPPUNIT_ASSERT_EQUAL(1,m->getSpaceDimension()); + MEDCouplingFieldDouble *f=m->getMeasureField(true); + CPPUNIT_ASSERT_EQUAL(3,f->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(1,f->getNumberOfComponents()); + const double expected1[3]={1.1,2.4,4.4}; + for(int i=0;i<3;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],f->getIJ(i,0),1e-12); + f->decrRef(); + DataArrayDouble *coords=m->getCoordinatesAndOwner(); + CPPUNIT_ASSERT_EQUAL(4,coords->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(1,coords->getNumberOfComponents()); + for(int i=0;i<4;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(discX[i],coords->getIJ(i,0),1e-12); + coords->decrRef(); + coords=m->getBarycenterAndOwner(); + CPPUNIT_ASSERT_EQUAL(3,coords->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(1,coords->getNumberOfComponents()); + const double expected1_3[3]={2.85,4.6,8.}; + for(int i=0;i<3;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1_3[i],coords->getIJ(i,0),1e-12); + coords->decrRef(); + // + da=DataArrayDouble::New(); + da->alloc(3,1); + std::copy(discY,discY+3,da->getPointer()); + m->setCoordsAt(1,da); + da->decrRef(); + m->checkCoherency(); + CPPUNIT_ASSERT_EQUAL(12,m->getNumberOfNodes()); + CPPUNIT_ASSERT_EQUAL(6,m->getNumberOfCells()); + CPPUNIT_ASSERT_EQUAL(2,m->getSpaceDimension()); + f=m->getMeasureField(true); + CPPUNIT_ASSERT_EQUAL(6,f->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(1,f->getNumberOfComponents()); + const double expected2[6]={12.21,26.64,48.84,24.64,53.76,98.56}; + for(int i=0;i<6;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected2[i],f->getIJ(i,0),1e-12); + f->decrRef(); + coords=m->getCoordinatesAndOwner(); + CPPUNIT_ASSERT_EQUAL(12,coords->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(2,coords->getNumberOfComponents()); + const double expected2_2[24]={2.3,12.3,3.4,12.3,5.8,12.3,10.2,12.3, 2.3,23.4,3.4,23.4,5.8,23.4,10.2,23.4, 2.3,45.8,3.4,45.8,5.8,45.8,10.2,45.8}; + for(int i=0;i<24;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected2_2[i],coords->getIJ(0,i),1e-12); + coords->decrRef(); + coords=m->getBarycenterAndOwner(); + CPPUNIT_ASSERT_EQUAL(6,coords->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(2,coords->getNumberOfComponents()); + const double expected2_3[12]={2.85,17.85,4.6,17.85,8.,17.85, 2.85,34.6,4.6,34.6,8.,34.6}; + for(int i=0;i<12;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected2_3[i],coords->getIJ(0,i),1e-12); + coords->decrRef(); + // + da=DataArrayDouble::New(); + da->alloc(5,1); + std::copy(discZ,discZ+5,da->getPointer()); + m->setCoordsAt(2,da); + da->decrRef(); + m->checkCoherency(); + CPPUNIT_ASSERT_EQUAL(60,m->getNumberOfNodes()); + CPPUNIT_ASSERT_EQUAL(24,m->getNumberOfCells()); + CPPUNIT_ASSERT_EQUAL(3,m->getSpaceDimension()); + f=m->getMeasureField(true); + CPPUNIT_ASSERT_EQUAL(24,f->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(1,f->getNumberOfComponents()); + const double expected3[24]={23.199, 50.616, 92.796, 46.816, 102.144, 187.264, 0.6105, 1.332, 2.442, 1.232, 2.688, 4.928, 10.7448, 23.4432, 42.9792, 21.6832, 47.3088, 86.7328, 6.5934, 14.3856, 26.3736, 13.3056, 29.0304, 53.2224}; + for(int i=0;i<24;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected3[i],f->getIJ(i,0),1e-12); + f->decrRef(); + coords=m->getCoordinatesAndOwner(); + CPPUNIT_ASSERT_EQUAL(60,coords->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(3,coords->getNumberOfComponents()); + const double expected3_2[180]={ + 2.3,12.3,-0.7, 3.4,12.3,-0.7, 5.8,12.3,-0.7, 10.2,12.3,-0.7, 2.3,23.4,-0.7, 3.4,23.4,-0.7, 5.8,23.4,-0.7, 10.2,23.4,-0.7, 2.3,45.8,-0.7, 3.4,45.8,-0.7, 5.8,45.8,-0.7, 10.2,45.8,-0.7, + 2.3,12.3,1.2, 3.4,12.3,1.2, 5.8,12.3,1.2, 10.2,12.3,1.2, 2.3,23.4,1.2, 3.4,23.4,1.2, 5.8,23.4,1.2, 10.2,23.4,1.2, 2.3,45.8,1.2, 3.4,45.8,1.2, 5.8,45.8,1.2, 10.2,45.8,1.2, + 2.3,12.3,1.25, 3.4,12.3,1.25, 5.8,12.3,1.25, 10.2,12.3,1.25, 2.3,23.4,1.25, 3.4,23.4,1.25, 5.8,23.4,1.25, 10.2,23.4,1.25, 2.3,45.8,1.25, 3.4,45.8,1.25, 5.8,45.8,1.25, 10.2,45.8,1.25, + 2.3,12.3,2.13, 3.4,12.3,2.13, 5.8,12.3,2.13, 10.2,12.3,2.13, 2.3,23.4,2.13, 3.4,23.4,2.13, 5.8,23.4,2.13, 10.2,23.4,2.13, 2.3,45.8,2.13, 3.4,45.8,2.13, 5.8,45.8,2.13, 10.2,45.8,2.13, + 2.3,12.3,2.67, 3.4,12.3,2.67, 5.8,12.3,2.67, 10.2,12.3,2.67, 2.3,23.4,2.67, 3.4,23.4,2.67, 5.8,23.4,2.67, 10.2,23.4,2.67, 2.3,45.8,2.67, 3.4,45.8,2.67, 5.8,45.8,2.67, 10.2,45.8,2.67 + }; + for(int i=0;i<180;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected3_2[i],coords->getIJ(0,i),1e-12); + coords->decrRef(); + coords=m->getBarycenterAndOwner(); + CPPUNIT_ASSERT_EQUAL(24,coords->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(3,coords->getNumberOfComponents()); + const double expected3_3[72]={ + 2.85,17.85,0.25,4.6,17.85,0.25,8.,17.85,0.25, 2.85,34.6,0.25,4.6,34.6,0.25,8.,34.6,0.25, + 2.85,17.85,1.225,4.6,17.85,1.225,8.,17.85,1.225, 2.85,34.6,1.225,4.6,34.6,1.225,8.,34.6,1.225, + 2.85,17.85,1.69,4.6,17.85,1.69,8.,17.85,1.69, 2.85,34.6,1.69,4.6,34.6,1.69,8.,34.6,1.69, + 2.85,17.85,2.4,4.6,17.85,2.4,8.,17.85,2.4, 2.85,34.6,2.4,4.6,34.6,2.4,8.,34.6,2.4 + }; + for(int i=0;i<72;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected3_3[i],coords->getIJ(0,i),1e-12); + coords->decrRef(); + // + m->decrRef(); +} + +void MEDCouplingBasicsTest::testFieldDoubleZipCoords1() +{ + MEDCouplingUMesh *m=build2DTargetMeshMergeNode_1(); + MEDCouplingFieldDouble *f=m->fillFromAnalytic(ON_NODES,2,"x*2."); + f->getArray()->setInfoOnComponent(0,"titi"); + f->getArray()->setInfoOnComponent(1,"tutu"); + f->checkCoherency(); + CPPUNIT_ASSERT_EQUAL(18,f->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(2,f->getNumberOfComponents()); + const double expected1[36]={-0.6, -0.6, 0.4, 0.4, 1.4, 1.4, -0.6, -0.6, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 1.4, 1.4, -0.6, -0.6, 0.4, 0.4, 1.4, 1.4, -0.6, -0.6, 1.4, 1.4, -0.6, -0.6, 0.4, 0.4, 1.4, 1.4, 0.4, 0.4}; + for(int i=0;i<36;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],f->getIJ(0,i),1e-12); + CPPUNIT_ASSERT(f->zipCoords()); + f->checkCoherency(); + const double expected2[30]={-0.6, -0.6, 1.4, 1.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 1.4, 1.4, -0.6, -0.6, 0.4, 0.4, 1.4, 1.4, 1.4, 1.4, -0.6, -0.6, 0.4, 0.4, 1.4, 1.4, 0.4, 0.4}; + for(int i=0;i<30;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected2[i],f->getIJ(0,i),1e-12); + CPPUNIT_ASSERT(!f->zipCoords()); + f->checkCoherency(); + for(int i=0;i<30;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected2[i],f->getIJ(0,i),1e-12); + CPPUNIT_ASSERT(std::string(f->getArray()->getInfoOnComponent(0))=="titi"); + CPPUNIT_ASSERT(std::string(f->getArray()->getInfoOnComponent(1))=="tutu"); + f->decrRef(); + m->decrRef(); +} + +void MEDCouplingBasicsTest::testFieldDoubleZipConnectivity1() +{ + MEDCouplingUMesh *m1=build2DTargetMesh_1(); + MEDCouplingUMesh *m2=build2DTargetMesh_1(); + const int cells1[3]={2,3,4}; + MEDCouplingPointSet *m3_1=m2->buildPartOfMySelf(cells1,cells1+3,true); + MEDCouplingUMesh *m3=dynamic_cast(m3_1); + CPPUNIT_ASSERT(m3); + m2->decrRef(); + MEDCouplingUMesh *m4=build2DSourceMesh_1(); + MEDCouplingUMesh *m5=MEDCouplingUMesh::mergeUMeshes(m1,m3); + m1->decrRef(); + m3->decrRef(); + MEDCouplingUMesh *m6=MEDCouplingUMesh::mergeUMeshes(m5,m4); + m4->decrRef(); + m5->decrRef(); + // + CPPUNIT_ASSERT_EQUAL(10,m6->getNumberOfCells()); + CPPUNIT_ASSERT_EQUAL(22,m6->getNumberOfNodes()); + bool areNodesMerged; + int newNbOfNodes; + DataArrayInt *arr=m6->mergeNodes(1e-13,areNodesMerged,newNbOfNodes); + CPPUNIT_ASSERT_EQUAL(9,m6->getNumberOfNodes()); + arr->decrRef(); + MEDCouplingFieldDouble *f=m6->fillFromAnalytic(ON_CELLS,2,"x"); + MEDCouplingFieldDouble *f2=m6->fillFromAnalytic(ON_NODES,2,"x"); + CPPUNIT_ASSERT_EQUAL(10,f->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(2,f->getNumberOfComponents()); + const double expected1[20]={-0.05, -0.05, 0.3666666666666667, 0.3666666666666667, 0.53333333333333321, 0.53333333333333321, + -0.05, -0.05, 0.45, 0.45, 0.53333333333333321, 0.53333333333333321, -0.05, -0.05, 0.45, 0.45, + 0.36666666666666659, 0.36666666666666659, 0.033333333333333326, 0.033333333333333326}; + for(int i=0;i<20;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],f->getIJ(0,i),1e-12); + f->getArray()->setInfoOnComponent(0,"titi"); + f->getArray()->setInfoOnComponent(1,"tutu"); + f->checkCoherency(); + CPPUNIT_ASSERT(f->zipConnectivity(0)); + const double expected2[14]={-0.05, -0.05, 0.3666666666666667, 0.3666666666666667, 0.53333333333333321, 0.53333333333333321, + -0.05, -0.05, 0.45, 0.45, 0.36666666666666659, 0.36666666666666659, 0.033333333333333326, 0.033333333333333326}; + CPPUNIT_ASSERT_EQUAL(7,f->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(2,f->getNumberOfComponents()); + for(int i=0;i<14;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected2[i],f->getIJ(0,i),1e-12); + CPPUNIT_ASSERT(std::string(f->getArray()->getInfoOnComponent(0))=="titi"); + CPPUNIT_ASSERT(std::string(f->getArray()->getInfoOnComponent(1))=="tutu"); + CPPUNIT_ASSERT(!f->zipConnectivity(0)); + f->decrRef(); + // + const double expected3[18]={-0.3, -0.3, 0.2, 0.2, 0.7, 0.7, -0.3, -0.3, 0.2, 0.2, 0.7, 0.7, + -0.3, -0.3, 0.2, 0.2, 0.7, 0.7}; + CPPUNIT_ASSERT_EQUAL(9,f2->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(2,f2->getNumberOfComponents()); + for(int i=0;i<18;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected3[i],f2->getIJ(0,i),1e-12); + CPPUNIT_ASSERT(f2->zipConnectivity(0)); + CPPUNIT_ASSERT_EQUAL(9,f2->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(2,f2->getNumberOfComponents()); + for(int i=0;i<18;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected3[i],f2->getIJ(0,i),1e-12); + f2->decrRef(); + // + m6->decrRef(); +} + +void MEDCouplingBasicsTest::testDaDoubleRenumber1() +{ + DataArrayDouble *a=DataArrayDouble::New(); + a->alloc(7,2); + a->setInfoOnComponent(0,"toto"); + a->setInfoOnComponent(1,"tata"); + const double arr1[14]={1.1,11.1,2.1,12.1,3.1,13.1,4.1,14.1,5.1,15.1,6.1,16.1,7.1,17.1}; + std::copy(arr1,arr1+14,a->getPointer()); + // + const int arr2[7]={3,1,0,6,5,4,2}; + DataArrayDouble *b=a->renumber(arr2); + CPPUNIT_ASSERT_EQUAL(7,b->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(2,b->getNumberOfComponents()); + CPPUNIT_ASSERT(std::string(b->getInfoOnComponent(0))=="toto"); + CPPUNIT_ASSERT(std::string(b->getInfoOnComponent(1))=="tata"); + const double expected1[14]={3.1, 13.1, 2.1, 12.1, 7.1, 17.1, 1.1, 11.1, 6.1, 16.1, 5.1, 15.1, 4.1, 14.1}; + for(int i=0;i<14;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],b->getIJ(0,i),1e-14); + b->decrRef(); + a->decrRef(); + // + DataArrayInt *c=DataArrayInt::New(); + c->alloc(7,2); + c->setInfoOnComponent(0,"toto"); + c->setInfoOnComponent(1,"tata"); + const int arr3[14]={1,11,2,12,3,13,4,14,5,15,6,16,7,17}; + std::copy(arr3,arr3+14,c->getPointer()); + DataArrayInt *d=c->renumber(arr2); + CPPUNIT_ASSERT_EQUAL(7,d->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(2,d->getNumberOfComponents()); + CPPUNIT_ASSERT(std::string(d->getInfoOnComponent(0))=="toto"); + CPPUNIT_ASSERT(std::string(d->getInfoOnComponent(1))=="tata"); + const int expected2[14]={3, 13, 2, 12, 7, 17, 1, 11, 6, 16, 5, 15, 4, 14}; + for(int i=0;i<14;i++) + CPPUNIT_ASSERT_EQUAL(expected2[i],d->getIJ(0,i)); + c->decrRef(); + d->decrRef(); +} + +void MEDCouplingBasicsTest::testDaDoubleRenumberAndReduce1() +{ + DataArrayDouble *a=DataArrayDouble::New(); + a->alloc(7,2); + a->setInfoOnComponent(0,"toto"); + a->setInfoOnComponent(1,"tata"); + const double arr1[14]={1.1,11.1,2.1,12.1,3.1,13.1,4.1,14.1,5.1,15.1,6.1,16.1,7.1,17.1}; + std::copy(arr1,arr1+14,a->getPointer()); + // + const int arr2[7]={2,-1,1,-1,0,4,3}; + DataArrayDouble *b=a->renumberAndReduce(arr2,5); + CPPUNIT_ASSERT_EQUAL(5,b->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(2,b->getNumberOfComponents()); + CPPUNIT_ASSERT(std::string(b->getInfoOnComponent(0))=="toto"); + CPPUNIT_ASSERT(std::string(b->getInfoOnComponent(1))=="tata"); + const double expected1[10]={5.1,15.1,3.1,13.1,1.1,11.1,7.1,17.1,6.1,16.1}; + for(int i=0;i<10;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],b->getIJ(0,i),1e-14); + b->decrRef(); + a->decrRef(); + // + DataArrayInt *c=DataArrayInt::New(); + c->alloc(7,2); + c->setInfoOnComponent(0,"toto"); + c->setInfoOnComponent(1,"tata"); + const int arr3[14]={1,11,2,12,3,13,4,14,5,15,6,16,7,17}; + std::copy(arr3,arr3+14,c->getPointer()); + DataArrayInt *d=c->renumberAndReduce(arr2,5); + CPPUNIT_ASSERT_EQUAL(5,d->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(2,d->getNumberOfComponents()); + CPPUNIT_ASSERT(std::string(d->getInfoOnComponent(0))=="toto"); + CPPUNIT_ASSERT(std::string(d->getInfoOnComponent(1))=="tata"); + const int expected2[10]={5,15,3,13,1,11,7,17,6,16}; + for(int i=0;i<10;i++) + CPPUNIT_ASSERT_EQUAL(expected2[i],d->getIJ(0,i)); + c->decrRef(); + d->decrRef(); +} + +void MEDCouplingBasicsTest::testDaDoubleRenumberInPlace1() +{ + DataArrayDouble *a=DataArrayDouble::New(); + a->alloc(7,2); + const double arr1[14]={1.1,11.1,2.1,12.1,3.1,13.1,4.1,14.1,5.1,15.1,6.1,16.1,7.1,17.1}; + std::copy(arr1,arr1+14,a->getPointer()); + // + const int arr2[7]={3,1,0,6,5,4,2}; + a->renumberInPlace(arr2); + CPPUNIT_ASSERT_EQUAL(7,a->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(2,a->getNumberOfComponents()); + const double expected1[14]={3.1, 13.1, 2.1, 12.1, 7.1, 17.1, 1.1, 11.1, 6.1, 16.1, 5.1, 15.1, 4.1, 14.1}; + for(int i=0;i<14;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],a->getIJ(0,i),1e-14); + a->decrRef(); + // + DataArrayInt *c=DataArrayInt::New(); + c->alloc(7,2); + const int arr3[14]={1,11,2,12,3,13,4,14,5,15,6,16,7,17}; + std::copy(arr3,arr3+14,c->getPointer()); + c->renumberInPlace(arr2); + CPPUNIT_ASSERT_EQUAL(7,c->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(2,c->getNumberOfComponents()); + const int expected2[14]={3, 13, 2, 12, 7, 17, 1, 11, 6, 16, 5, 15, 4, 14}; + for(int i=0;i<14;i++) + CPPUNIT_ASSERT_EQUAL(expected2[i],c->getIJ(0,i)); + c->decrRef(); +} + +void MEDCouplingBasicsTest::testDaDoubleRenumberR1() +{ + DataArrayDouble *a=DataArrayDouble::New(); + a->alloc(7,2); + a->setInfoOnComponent(0,"toto"); + a->setInfoOnComponent(1,"tata"); + const double arr1[14]={1.1,11.1,2.1,12.1,3.1,13.1,4.1,14.1,5.1,15.1,6.1,16.1,7.1,17.1}; + std::copy(arr1,arr1+14,a->getPointer()); + // + const int arr2[7]={3,1,0,6,5,4,2}; + DataArrayDouble *b=a->renumberR(arr2); + CPPUNIT_ASSERT_EQUAL(7,b->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(2,b->getNumberOfComponents()); + CPPUNIT_ASSERT(std::string(b->getInfoOnComponent(0))=="toto"); + CPPUNIT_ASSERT(std::string(b->getInfoOnComponent(1))=="tata"); + const double expected1[14]={4.1, 14.1, 2.1, 12.1, 1.1, 11.1, 7.1, 17.1, 6.1, 16.1, 5.1, 15.1, 3.1, 13.1}; + for(int i=0;i<14;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],b->getIJ(0,i),1e-14); + b->decrRef(); + a->decrRef(); + // + DataArrayInt *c=DataArrayInt::New(); + c->alloc(7,2); + c->setInfoOnComponent(0,"toto"); + c->setInfoOnComponent(1,"tata"); + const int arr3[14]={1,11,2,12,3,13,4,14,5,15,6,16,7,17}; + std::copy(arr3,arr3+14,c->getPointer()); + DataArrayInt *d=c->renumberR(arr2); + CPPUNIT_ASSERT_EQUAL(7,d->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(2,d->getNumberOfComponents()); + CPPUNIT_ASSERT(std::string(d->getInfoOnComponent(0))=="toto"); + CPPUNIT_ASSERT(std::string(d->getInfoOnComponent(1))=="tata"); + const int expected2[14]={4, 14, 2, 12, 1, 11, 7, 17, 6, 16, 5, 15, 3, 13}; + for(int i=0;i<14;i++) + CPPUNIT_ASSERT_EQUAL(expected2[i],d->getIJ(0,i)); + c->decrRef(); + d->decrRef(); +} + +void MEDCouplingBasicsTest::testDaDoubleRenumberInPlaceR1() +{ + DataArrayDouble *a=DataArrayDouble::New(); + a->alloc(7,2); + const double arr1[14]={1.1,11.1,2.1,12.1,3.1,13.1,4.1,14.1,5.1,15.1,6.1,16.1,7.1,17.1}; + std::copy(arr1,arr1+14,a->getPointer()); + // + const int arr2[7]={3,1,0,6,5,4,2}; + a->renumberInPlaceR(arr2); + CPPUNIT_ASSERT_EQUAL(7,a->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(2,a->getNumberOfComponents()); + const double expected1[14]={4.1, 14.1, 2.1, 12.1, 1.1, 11.1, 7.1, 17.1, 6.1, 16.1, 5.1, 15.1, 3.1, 13.1}; + for(int i=0;i<14;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],a->getIJ(0,i),1e-14); + a->decrRef(); + // + DataArrayInt *c=DataArrayInt::New(); + c->alloc(7,2); + const int arr3[14]={1,11,2,12,3,13,4,14,5,15,6,16,7,17}; + std::copy(arr3,arr3+14,c->getPointer()); + c->renumberInPlaceR(arr2); + CPPUNIT_ASSERT_EQUAL(7,c->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(2,c->getNumberOfComponents()); + const int expected2[14]={4, 14, 2, 12, 1, 11, 7, 17, 6, 16, 5, 15, 3, 13}; + for(int i=0;i<14;i++) + CPPUNIT_ASSERT_EQUAL(expected2[i],c->getIJ(0,i)); + c->decrRef(); +} + +void MEDCouplingBasicsTest::testDaDoubleSelectByTupleId1() +{ + DataArrayDouble *a=DataArrayDouble::New(); + a->alloc(7,2); + a->setInfoOnComponent(0,"toto"); + a->setInfoOnComponent(1,"tata"); + const double arr1[14]={1.1,11.1,2.1,12.1,3.1,13.1,4.1,14.1,5.1,15.1,6.1,16.1,7.1,17.1}; + std::copy(arr1,arr1+14,a->getPointer()); + // + const int arr2[7]={4,2,0,6,5}; + DataArrayDouble *b=a->selectByTupleId(arr2,arr2+5); + CPPUNIT_ASSERT_EQUAL(5,b->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(2,b->getNumberOfComponents()); + CPPUNIT_ASSERT(std::string(b->getInfoOnComponent(0))=="toto"); + CPPUNIT_ASSERT(std::string(b->getInfoOnComponent(1))=="tata"); + const double expected1[10]={5.1,15.1,3.1,13.1,1.1,11.1,7.1,17.1,6.1,16.1}; + for(int i=0;i<10;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],b->getIJ(0,i),1e-14); + b->decrRef(); + a->decrRef(); + // + DataArrayInt *c=DataArrayInt::New(); + c->alloc(7,2); + c->setInfoOnComponent(0,"toto"); + c->setInfoOnComponent(1,"tata"); + const int arr3[14]={1,11,2,12,3,13,4,14,5,15,6,16,7,17}; + std::copy(arr3,arr3+14,c->getPointer()); + DataArrayInt *d=c->selectByTupleId(arr2,arr2+5); + CPPUNIT_ASSERT_EQUAL(5,d->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(2,d->getNumberOfComponents()); + CPPUNIT_ASSERT(std::string(d->getInfoOnComponent(0))=="toto"); + CPPUNIT_ASSERT(std::string(d->getInfoOnComponent(1))=="tata"); + const int expected2[10]={5,15,3,13,1,11,7,17,6,16}; + for(int i=0;i<10;i++) + CPPUNIT_ASSERT_EQUAL(expected2[i],d->getIJ(0,i)); + c->decrRef(); + d->decrRef(); +} + +void MEDCouplingBasicsTest::testDaDoubleGetMinMaxValues1() +{ + DataArrayDouble *a=DataArrayDouble::New(); + a->alloc(9,1); + const double arr1[9]={2.34,4.56,-6.77,4.55,4.56,2.24,2.34,1.02,4.56}; + std::copy(arr1,arr1+9,a->getPointer()); + int where; + double m=a->getMaxValue(where); + CPPUNIT_ASSERT_EQUAL(1,where); + CPPUNIT_ASSERT_DOUBLES_EQUAL(4.56,m,1e-12); + DataArrayInt *ws; + m=a->getMaxValue2(ws); + CPPUNIT_ASSERT_DOUBLES_EQUAL(4.56,m,1e-12); + CPPUNIT_ASSERT_EQUAL(3,ws->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(1,ws->getNumberOfComponents()); + const int expected1[3]={1,4,8}; + for(int i=0;i<3;i++) + CPPUNIT_ASSERT_EQUAL(expected1[i],ws->getIJ(i,0)); + ws->decrRef(); + a->decrRef(); + a=DataArrayDouble::New(); + const double arr2[9]={-2.34,-4.56,6.77,-4.55,-4.56,-2.24,-2.34,-1.02,-4.56}; + a->alloc(9,1); + std::copy(arr2,arr2+9,a->getPointer()); + where=-2; + m=a->getMinValue(where); + CPPUNIT_ASSERT_EQUAL(1,where); + CPPUNIT_ASSERT_DOUBLES_EQUAL(-4.56,m,1e-12); + m=a->getMinValue2(ws); + CPPUNIT_ASSERT_DOUBLES_EQUAL(-4.56,m,1e-12); + CPPUNIT_ASSERT_EQUAL(3,ws->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(1,ws->getNumberOfComponents()); + for(int i=0;i<3;i++) + CPPUNIT_ASSERT_EQUAL(expected1[i],ws->getIJ(i,0)); + ws->decrRef(); + a->decrRef(); +} + +void MEDCouplingBasicsTest::testFieldDoubleGetMinMaxValues2() +{ + MEDCouplingUMesh *m1=0; + MEDCouplingUMesh *m2=build3DExtrudedUMesh_1(m1); + m1->decrRef(); + CPPUNIT_ASSERT_EQUAL(18,m2->getNumberOfCells()); + const double arr1[18]={8.71,4.53,-12.41,8.71,-8.71,8.7099,4.55,8.71,5.55,6.77,-1e-200,4.55,8.7099,0.,1.23,0.,2.22,8.71}; + MEDCouplingFieldDouble *f=MEDCouplingFieldDouble::New(ON_CELLS,NO_TIME); + DataArrayDouble *a=DataArrayDouble::New(); + a->alloc(18,1); + std::copy(arr1,arr1+18,a->getPointer()); + f->setArray(a); + a->decrRef(); + f->setMesh(m2); + // + f->checkCoherency(); + double m=f->getMaxValue(); + CPPUNIT_ASSERT_DOUBLES_EQUAL(8.71,m,1e-12); + DataArrayInt *ws; + m=f->getMaxValue2(ws); + CPPUNIT_ASSERT_DOUBLES_EQUAL(8.71,m,1e-12); + CPPUNIT_ASSERT_EQUAL(4,ws->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(1,ws->getNumberOfComponents()); + const int expected1[4]={0,3,7,17}; + for(int i=0;i<4;i++) + CPPUNIT_ASSERT_EQUAL(expected1[i],ws->getIJ(i,0)); + ws->decrRef(); + // + const double arr2[18]={-8.71,-4.53,12.41,-8.71,8.71,-8.7099,-4.55,-8.71,-5.55,-6.77,1e-200,-4.55,-8.7099,0.,-1.23,0.,-2.22,-8.71}; + std::copy(arr2,arr2+18,a->getPointer()); + f->checkCoherency(); + m=f->getMinValue(); + CPPUNIT_ASSERT_DOUBLES_EQUAL(-8.71,m,1e-12); + m=f->getMinValue2(ws); + CPPUNIT_ASSERT_DOUBLES_EQUAL(-8.71,m,1e-12); + CPPUNIT_ASSERT_EQUAL(4,ws->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(1,ws->getNumberOfComponents()); + for(int i=0;i<4;i++) + CPPUNIT_ASSERT_EQUAL(expected1[i],ws->getIJ(i,0)); + ws->decrRef(); + // + f->decrRef(); + m2->decrRef(); +} + +void MEDCouplingBasicsTest::testBuildUnstructuredCMesh1() +{ + MEDCouplingCMesh *m=MEDCouplingCMesh::New(); + DataArrayDouble *da=DataArrayDouble::New(); + const double discX[4]={2.3,3.4,5.8,10.2}; + const double discY[3]={12.3,23.4,45.8}; + const double discZ[5]={-0.7,1.2,1.25,2.13,2.67}; + da->alloc(4,1); + std::copy(discX,discX+4,da->getPointer()); + m->setCoordsAt(0,da); + da->decrRef(); + m->checkCoherency(); + double pos=2.4; + CPPUNIT_ASSERT_EQUAL(0,m->getCellContainingPoint(&pos,1e-12)); + pos=3.7; + CPPUNIT_ASSERT_EQUAL(1,m->getCellContainingPoint(&pos,1e-12)); + pos=5.9; + CPPUNIT_ASSERT_EQUAL(2,m->getCellContainingPoint(&pos,1e-12)); + pos=10.3; + CPPUNIT_ASSERT_EQUAL(-1,m->getCellContainingPoint(&pos,1e-12)); + pos=1.3; + CPPUNIT_ASSERT_EQUAL(-1,m->getCellContainingPoint(&pos,1e-12)); + // + MEDCouplingUMesh *m2=m->buildUnstructured(); + m2->checkCoherency(); + MEDCouplingFieldDouble *f1=m->getMeasureField(false); + MEDCouplingFieldDouble *f2=m2->getMeasureField(false); + CPPUNIT_ASSERT_EQUAL(f1->getNumberOfTuples(),3); + CPPUNIT_ASSERT_EQUAL(f2->getNumberOfTuples(),3); + CPPUNIT_ASSERT_EQUAL(1,m2->getMeshDimension()); + CPPUNIT_ASSERT_EQUAL(1,m2->getSpaceDimension()); + for(int i=0;i<3;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(f1->getIJ(i,0),f2->getIJ(i,0),1e-10); + da=DataArrayDouble::New(); + da->alloc(3,1); + std::copy(discY,discY+3,da->getPointer()); + m->setCoordsAt(1,da); + da->decrRef(); + m2->decrRef(); + f1->decrRef(); + f2->decrRef(); + // + m2=m->buildUnstructured(); + m2->checkCoherency(); + f1=m->getMeasureField(false); + f2=m2->getMeasureField(false); + CPPUNIT_ASSERT_EQUAL(f1->getNumberOfTuples(),6); + CPPUNIT_ASSERT_EQUAL(f2->getNumberOfTuples(),6); + CPPUNIT_ASSERT_EQUAL(2,m2->getMeshDimension()); + CPPUNIT_ASSERT_EQUAL(2,m2->getSpaceDimension()); + for(int i=0;i<6;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(f1->getIJ(i,0),f2->getIJ(i,0),1e-10); + f1->decrRef(); + f2->decrRef(); + m2->decrRef(); + // + da=DataArrayDouble::New(); + da->alloc(5,1); + std::copy(discZ,discZ+5,da->getPointer()); + m->setCoordsAt(2,da); + da->decrRef(); + m2=m->buildUnstructured(); + m2->checkCoherency(); + f1=m->getMeasureField(false); + f2=m2->getMeasureField(false); + CPPUNIT_ASSERT_EQUAL(f1->getNumberOfTuples(),24); + CPPUNIT_ASSERT_EQUAL(f2->getNumberOfTuples(),24); + CPPUNIT_ASSERT_EQUAL(3,m2->getMeshDimension()); + CPPUNIT_ASSERT_EQUAL(3,m2->getSpaceDimension()); + for(int i=0;i<24;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(f1->getIJ(i,0),f2->getIJ(i,0),1e-10); + f1->decrRef(); + f2->decrRef(); + // + double pos1[3]={5.,30.,2.}; + CPPUNIT_ASSERT_EQUAL(16,m->getCellContainingPoint(pos1,1e-12)); + // + const double pt[3]={2.4,12.7,-3.4}; + m->scale(pt,3.7); + MEDCouplingUMesh *m3=m->buildUnstructured(); + m2->scale(pt,3.7); + CPPUNIT_ASSERT(m3->isEqual(m2,1e-12)); + m2->decrRef(); + m3->decrRef(); + // + m->decrRef(); +} + +void MEDCouplingBasicsTest::testDataArrayIntInvertO2NNO21() +{ + const int arr1[6]={2,0,4,1,5,3}; + DataArrayInt *da=DataArrayInt::New(); + da->alloc(6,1); + std::copy(arr1,arr1+6,da->getPointer()); + DataArrayInt *da2=da->invertArrayO2N2N2O(6); + CPPUNIT_ASSERT_EQUAL(6,da2->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(1,da2->getNumberOfComponents()); + const int expected1[6]={1,3,0,5,2,4}; + for(int i=0;i<6;i++) + CPPUNIT_ASSERT_EQUAL(expected1[i],da2->getIJ(i,0)); + DataArrayInt *da3=da2->invertArrayN2O2O2N(6); + for(int i=0;i<6;i++) + CPPUNIT_ASSERT_EQUAL(arr1[i],da3->getIJ(i,0)); + da3->decrRef(); + da2->decrRef(); + da->decrRef(); + // + const int arr2[10]={3,-1,5,4,-1,0,-1,1,2,-1}; + da=DataArrayInt::New(); + da->alloc(10,1); + std::copy(arr2,arr2+10,da->getPointer()); + da2=da->invertArrayO2N2N2O(6); + CPPUNIT_ASSERT_EQUAL(6,da2->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(1,da2->getNumberOfComponents()); + const int expected2[10]={5,7,8,0,3,2}; + for(int i=0;i<6;i++) + CPPUNIT_ASSERT_EQUAL(expected2[i],da2->getIJ(i,0)); + da3=da2->invertArrayN2O2O2N(10); + for(int i=0;i<10;i++) + CPPUNIT_ASSERT_EQUAL(arr2[i],da3->getIJ(i,0)); + da3->decrRef(); + da2->decrRef(); + da->decrRef(); +} diff --git a/src/MEDCoupling_Swig/MEDCouplingBasicsTest.py b/src/MEDCoupling_Swig/MEDCouplingBasicsTest.py index 53cd9f4df..474df2db3 100644 --- a/src/MEDCoupling_Swig/MEDCouplingBasicsTest.py +++ b/src/MEDCoupling_Swig/MEDCouplingBasicsTest.py @@ -446,7 +446,7 @@ class MEDCouplingBasicsTest(unittest.TestCase): subMesh=mesh.buildPartOfMySelf(tab1,True); self.assertTrue(isinstance(subMesh,MEDCouplingUMesh)) traducer=subMesh.zipCoordsTraducer(); - expectedTraducer=[0,1,3,4,5,7,8] + expectedTraducer=[0, 1, -1, 2, 3, 4, -1, 5, 6] self.assertEqual(expectedTraducer,list(traducer.getValues())); self.assertEqual(NORM_QUAD4,subMesh.getAllTypes()[0]); self.assertEqual(2,subMesh.getNumberOfCells()); @@ -978,9 +978,11 @@ class MEDCouplingBasicsTest(unittest.TestCase): self.assertTrue(abs(tmp[i]-values3[i])<1.e-12) pass values4=f1.accumulate(); + self.assertEqual(2,len(values4)) self.assertTrue(abs(3.6-values4[0])<1.e-12); self.assertTrue(abs(7.2-values4[1])<1.e-12); values4=f1.integral(True); + self.assertEqual(2,len(values4)) self.assertTrue(abs(0.5-values4[0])<1.e-12); self.assertTrue(abs(1.-values4[1])<1.e-12); # @@ -1996,7 +1998,9 @@ class MEDCouplingBasicsTest(unittest.TestCase): self.assertTrue(abs(expected2[i]-ptr[i])<1e-12); pass #integral + self.assertTrue(4,f1.getNumberOfTuples()) res=f1.integral(False); + self.assertTrue(3,len(res)) expected3=[0.9866,-0.3615,0.4217] for i in xrange(3): self.assertTrue(abs(expected3[i]-res[i])<1e-12); @@ -2011,6 +2015,7 @@ class MEDCouplingBasicsTest(unittest.TestCase): pass #normL1 res=f1.normL1(); + self.assertTrue(3,len(res)) expected5=[11.3068,27.3621,43.7881] for i in xrange(3): self.assertTrue(abs(expected5[i]-res[i])<1e-12); @@ -2020,6 +2025,7 @@ class MEDCouplingBasicsTest(unittest.TestCase): self.assertTrue(abs(expected5[2]-f1.normL1(2))<1e-12); #normL2 res=f1.normL2(); + self.assertTrue(3,len(res)) expected7=[9.0252562290496776, 21.545259176904789, 34.433193070059595] for i in xrange(3): self.assertTrue(abs(expected7[i]-res[i])<1e-9); @@ -3399,6 +3405,723 @@ class MEDCouplingBasicsTest(unittest.TestCase): self.assertAlmostEqual(expected2[i],f1.getIJ(i,0),14); pass pass + + def testFillFromAnalytic3(self): + m=MEDCouplingDataForTest.build2DTargetMesh_1() + f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME) + self.assertRaises(Exception,f1.fillFromAnalytic,1,"y+x"); + f1.setMesh(m) + f1.setName("myField"); + f1.fillFromAnalytic(1,"y+x"); + f1.checkCoherency(); + self.assertEqual(f1.getName(),"myField"); + self.assertEqual(f1.getTypeOfField(),ON_CELLS); + self.assertEqual(f1.getTimeDiscretization(),ONE_TIME); + self.assertEqual(1,f1.getNumberOfComponents()); + self.assertEqual(5,f1.getNumberOfTuples()); + values1=[-0.1,0.23333333333333336,0.56666666666666665,0.4,0.9] + tmp=f1.getArray().getValues(); + self.assertEqual(len(values1),len(tmp)) + for i in xrange(len(values1)): + self.assertTrue(abs(values1[i]-tmp[i])<1.e-12); + pass + # + f1=MEDCouplingFieldDouble.New(ON_NODES,CONST_ON_TIME_INTERVAL) + f1.setMesh(m) + f1.fillFromAnalytic(1,"y+2*x"); + f1.setEndTime(1.2,3,4); + f1.checkCoherency(); + self.assertEqual(f1.getTypeOfField(),ON_NODES); + self.assertEqual(f1.getTimeDiscretization(),CONST_ON_TIME_INTERVAL); + self.assertEqual(1,f1.getNumberOfComponents()); + self.assertEqual(9,f1.getNumberOfTuples()); + values2=[-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1] + tmp=f1.getArray().getValues(); + self.assertEqual(len(values2),len(tmp)) + for i in xrange(len(values2)): + self.assertTrue(abs(values2[i]-tmp[i])<1.e-12); + pass + f1=MEDCouplingFieldDouble.New(ON_NODES,LINEAR_TIME); + f1.setMesh(m) + f1.fillFromAnalytic(1,"2.*x+y"); + f1.setEndTime(1.2,3,4); + f1.checkCoherency(); + self.assertEqual(f1.getTypeOfField(),ON_NODES); + self.assertEqual(f1.getTimeDiscretization(),LINEAR_TIME); + self.assertEqual(1,f1.getNumberOfComponents()); + self.assertEqual(9,f1.getNumberOfTuples()); + tmp=f1.getArray().getValues(); + values2Bis=[-0.9,0.1,1.1,-0.4,0.6,1.6,0.1,1.1,2.1] + self.assertEqual(len(values2Bis),len(tmp)) + for i in xrange(len(values2Bis)): + self.assertTrue(abs(values2Bis[i]-tmp[i])<1.e-12); + pass + tmp=f1.getEndArray().getValues(); + self.assertEqual(len(values2Bis),len(tmp)) + for i in xrange(len(values2Bis)): + self.assertTrue(abs(values2Bis[i]-tmp[i])<1.e-12); + pass + # + f1=MEDCouplingFieldDouble.New(ON_NODES,ONE_TIME); + f1.setMesh(m) + f1.fillFromAnalytic(2,"(x+y)*IVec+2*(x+y)*JVec"); + f1.checkCoherency(); + self.assertEqual(f1.getTypeOfField(),ON_NODES); + self.assertEqual(f1.getTimeDiscretization(),ONE_TIME); + self.assertEqual(2,f1.getNumberOfComponents()); + self.assertEqual(9,f1.getNumberOfTuples()); + values3=[-0.6,-1.2,-0.1,-0.2,0.4,0.8,-0.1,-0.2,0.4,0.8,0.9,1.8,0.4,0.8,0.9,1.8,1.4,2.8] + tmp=f1.getArray().getValues(); + self.assertEqual(len(values3),len(tmp)) + for i in xrange(len(values3)): + self.assertTrue(abs(values3[i]-tmp[i])<1.e-12); + pass + values4=f1.accumulate(); + self.assertTrue(abs(3.6-values4[0])<1.e-12); + self.assertTrue(abs(7.2-values4[1])<1.e-12); + values4=f1.integral(True); + self.assertTrue(abs(0.5-values4[0])<1.e-12); + self.assertTrue(abs(1.-values4[1])<1.e-12); + # + f1=MEDCouplingFieldDouble.New(ON_NODES,NO_TIME); + f1.setMesh(m); + self.assertRaises(Exception,f1.fillFromAnalytic,1,"1./(x-0.2)"); + pass + + def testFieldDoubleOpEqual1(self): + m=MEDCouplingDataForTest.build2DTargetMesh_1(); + f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME); + self.assertRaises(Exception,f1.assign,0.07); + f1.setMesh(m); + f1.assign(0.07); + f1.checkCoherency(); + self.assertEqual(1,f1.getNumberOfComponents()); + self.assertEqual(5,f1.getNumberOfTuples()); + for i in xrange(5): + self.assertAlmostEqual(0.07,f1.getIJ(i,0),16); + pass + f1.assign(0.09); + f1.checkCoherency(); + self.assertEqual(1,f1.getNumberOfComponents()); + self.assertEqual(5,f1.getNumberOfTuples()); + for i in xrange(5): + self.assertAlmostEqual(0.09,f1.getIJ(i,0),16); + pass + # + f1=MEDCouplingFieldDouble.New(ON_NODES,LINEAR_TIME); + f1.setEndTime(4.5,2,3); + f1.setMesh(m); + f1.assign(0.08); + f1.checkCoherency(); + self.assertEqual(1,f1.getNumberOfComponents()); + self.assertEqual(9,f1.getNumberOfTuples()); + for i in xrange(9): + self.assertAlmostEqual(0.08,f1.getIJ(i,0),16); + pass + self.assertEqual(1,f1.getEndArray().getNumberOfComponents()); + self.assertEqual(9,f1.getEndArray().getNumberOfTuples()); + for i in xrange(9): + self.assertAlmostEqual(0.08,f1.getEndArray().getIJ(i,0),16); + pass + pass + + def testAreaBary3D2(self): + coordsForHexa8=[-75.45749305371, 180.95495078401, 39.515472018008, + -9.755591679144, 23.394927935279, 5.108794294848, + 14.337630157832, 61.705351002702, 160.42422501908, + -27.273893776752, 167.567731083961, 192.830034145464, + 99.857193154796,264.499264735586,-8.287335493412, + 144.939882761126,156.38626563134,-31.896173894226, + 161.34096835726,182.4654895809,73.832387065572, + 132.680430393685,255.37973247196,96.15235602819]; + volHexa8=3258520.29637466; + baryHexa8=[43.925705821778, 155.31893955289, 65.874418109644] + + coordsForPenta6=[-68.199829618726,178.938498373416,62.608505919588, + 8.461744647847,76.653979804423,165.00018874933, + -27.273893776752,167.567731083961,192.830034145464, + 106.586501038965,262.629609408327,13.124533008813, + 155.465082847275,197.414118382622,78.408350795821, + 132.680430393685,255.37973247196,96.15235602819]; + volPenta6=944849.868507338; + baryPenta6=[39.631002313543,182.692711783428,106.98540473964] + + coordsForPyra5=[132.680430393685,255.37973247196,96.15235602819, + -27.273893776752,167.567731083961,192.830034145464, + 8.461744647847,76.653979804423,165.00018874933, + 155.465082847275,197.414118382622,78.408350795821, + -68.199829618726,178.938498373416,62.608505919588]; + volPyra5=756943.92980254; + baryPyra5=[29.204294116618,172.540129749156,118.01035951483] + mesh=MEDCouplingUMesh.New("Bary3D2",3); + coo=DataArrayDouble.New(); + tmp=coordsForHexa8+coordsForPenta6+coordsForPyra5 + coo.setValues(tmp,19,3); + mesh.setCoords(coo); + # + tmpConn=[0,1,2,3,4,5,6,7] + mesh.allocateCells(3); + mesh.insertNextCell(NORM_HEXA8,8,tmpConn[0:8]) + mesh.insertNextCell(NORM_PENTA6,6,[i+8 for i in tmpConn]) + mesh.insertNextCell(NORM_PYRA5,5,[i+14 for i in tmpConn]) + mesh.finishInsertingCells(); + mesh.checkCoherency(); + mesh.mergeNodes(1e-7) + self.assertEqual(12,mesh.getNumberOfNodes()); + vols=mesh.getMeasureField(True); + self.assertEqual(3,vols.getNumberOfTuples()); + self.assertEqual(1,vols.getNumberOfComponents()); + self.assertAlmostEqual(volHexa8,vols.getIJ(0,0),6); + self.assertAlmostEqual(volPenta6,vols.getIJ(1,0),7); + self.assertAlmostEqual(volPyra5,vols.getIJ(2,0),7); + bary=mesh.getBarycenterAndOwner(); + self.assertEqual(3,bary.getNumberOfTuples()); + self.assertEqual(3,bary.getNumberOfComponents()); + self.assertAlmostEqual(baryHexa8[0],bary.getIJ(0,0),11); + self.assertAlmostEqual(baryHexa8[1],bary.getIJ(0,1),11); + self.assertAlmostEqual(baryHexa8[2],bary.getIJ(0,2),11); + self.assertAlmostEqual(baryPenta6[0],bary.getIJ(1,0),11); + self.assertAlmostEqual(baryPenta6[1],bary.getIJ(1,1),11); + self.assertAlmostEqual(baryPenta6[2],bary.getIJ(1,2),11); + self.assertAlmostEqual(baryPyra5[0],bary.getIJ(2,0),11); + self.assertAlmostEqual(baryPyra5[1],bary.getIJ(2,1),11); + self.assertAlmostEqual(baryPyra5[2],bary.getIJ(2,2),11); + pass + + def testGetMeasureFieldCMesh1(self): + m=MEDCouplingCMesh.New(); + da=DataArrayDouble.New(); + discX=[2.3,3.4,5.8,10.2] + discY=[12.3,23.4,45.8] + discZ=[-0.7,1.2,1.25,2.13,2.67] + da.setValues(discX,4,1); + m.setCoordsAt(0,da); + m.checkCoherency(); + self.assertEqual(4,m.getNumberOfNodes()); + self.assertEqual(3,m.getNumberOfCells()); + self.assertEqual(1,m.getSpaceDimension()); + f=m.getMeasureField(True); + self.assertEqual(3,f.getNumberOfTuples()); + self.assertEqual(1,f.getNumberOfComponents()); + expected1=[1.1,2.4,4.4] + for i in xrange(3): + self.assertAlmostEqual(expected1[i],f.getIJ(i,0),12); + pass + coords=m.getCoordinatesAndOwner(); + self.assertEqual(4,coords.getNumberOfTuples()); + self.assertEqual(1,coords.getNumberOfComponents()); + for i in xrange(4): + self.assertAlmostEqual(discX[i],coords.getIJ(i,0),12); + pass + coords=m.getBarycenterAndOwner(); + self.assertEqual(3,coords.getNumberOfTuples()); + self.assertEqual(1,coords.getNumberOfComponents()); + expected1_3=[2.85,4.6,8.] + for i in xrange(3): + self.assertAlmostEqual(expected1_3[i],coords.getIJ(i,0),12); + pass + # + da=DataArrayDouble.New(); + da.setValues(discY,3,1); + m.setCoordsAt(1,da); + m.checkCoherency(); + self.assertEqual(12,m.getNumberOfNodes()); + self.assertEqual(6,m.getNumberOfCells()); + self.assertEqual(2,m.getSpaceDimension()); + f=m.getMeasureField(True); + self.assertEqual(6,f.getNumberOfTuples()); + self.assertEqual(1,f.getNumberOfComponents()); + expected2=[12.21,26.64,48.84,24.64,53.76,98.56] + for i in xrange(6): + self.assertAlmostEqual(expected2[i],f.getIJ(i,0),12); + pass + coords=m.getCoordinatesAndOwner(); + self.assertEqual(12,coords.getNumberOfTuples()); + self.assertEqual(2,coords.getNumberOfComponents()); + expected2_2=[2.3,12.3,3.4,12.3,5.8,12.3,10.2,12.3, 2.3,23.4,3.4,23.4,5.8,23.4,10.2,23.4, 2.3,45.8,3.4,45.8,5.8,45.8,10.2,45.8] + for i in xrange(24): + self.assertAlmostEqual(expected2_2[i],coords.getIJ(0,i),12); + pass + coords=m.getBarycenterAndOwner(); + self.assertEqual(6,coords.getNumberOfTuples()); + self.assertEqual(2,coords.getNumberOfComponents()); + expected2_3=[2.85,17.85,4.6,17.85,8.,17.85, 2.85,34.6,4.6,34.6,8.,34.6] + for i in xrange(12): + self.assertAlmostEqual(expected2_3[i],coords.getIJ(0,i),12); + pass + # + da=DataArrayDouble.New(); + da.setValues(discZ,5,1); + m.setCoordsAt(2,da); + m.checkCoherency(); + self.assertEqual(60,m.getNumberOfNodes()); + self.assertEqual(24,m.getNumberOfCells()); + self.assertEqual(3,m.getSpaceDimension()); + f=m.getMeasureField(True); + self.assertEqual(24,f.getNumberOfTuples()); + self.assertEqual(1,f.getNumberOfComponents()); + expected3=[23.199, 50.616, 92.796, 46.816, 102.144, 187.264, 0.6105, 1.332, 2.442, 1.232, 2.688, 4.928, 10.7448, 23.4432, 42.9792, 21.6832, 47.3088, 86.7328, 6.5934, 14.3856, 26.3736, 13.3056, 29.0304, 53.2224] + for i in xrange(24): + self.assertAlmostEqual(expected3[i],f.getIJ(i,0),12); + pass + coords=m.getCoordinatesAndOwner(); + self.assertEqual(60,coords.getNumberOfTuples()); + self.assertEqual(3,coords.getNumberOfComponents()); + expected3_2=[ + 2.3,12.3,-0.7, 3.4,12.3,-0.7, 5.8,12.3,-0.7, 10.2,12.3,-0.7, 2.3,23.4,-0.7, 3.4,23.4,-0.7, 5.8,23.4,-0.7, 10.2,23.4,-0.7, 2.3,45.8,-0.7, 3.4,45.8,-0.7, 5.8,45.8,-0.7, 10.2,45.8,-0.7, + 2.3,12.3,1.2, 3.4,12.3,1.2, 5.8,12.3,1.2, 10.2,12.3,1.2, 2.3,23.4,1.2, 3.4,23.4,1.2, 5.8,23.4,1.2, 10.2,23.4,1.2, 2.3,45.8,1.2, 3.4,45.8,1.2, 5.8,45.8,1.2, 10.2,45.8,1.2, + 2.3,12.3,1.25, 3.4,12.3,1.25, 5.8,12.3,1.25, 10.2,12.3,1.25, 2.3,23.4,1.25, 3.4,23.4,1.25, 5.8,23.4,1.25, 10.2,23.4,1.25, 2.3,45.8,1.25, 3.4,45.8,1.25, 5.8,45.8,1.25, 10.2,45.8,1.25, + 2.3,12.3,2.13, 3.4,12.3,2.13, 5.8,12.3,2.13, 10.2,12.3,2.13, 2.3,23.4,2.13, 3.4,23.4,2.13, 5.8,23.4,2.13, 10.2,23.4,2.13, 2.3,45.8,2.13, 3.4,45.8,2.13, 5.8,45.8,2.13, 10.2,45.8,2.13, + 2.3,12.3,2.67, 3.4,12.3,2.67, 5.8,12.3,2.67, 10.2,12.3,2.67, 2.3,23.4,2.67, 3.4,23.4,2.67, 5.8,23.4,2.67, 10.2,23.4,2.67, 2.3,45.8,2.67, 3.4,45.8,2.67, 5.8,45.8,2.67, 10.2,45.8,2.67]; + for i in xrange(180): + self.assertAlmostEqual(expected3_2[i],coords.getIJ(0,i),12); + pass + coords=m.getBarycenterAndOwner(); + self.assertEqual(24,coords.getNumberOfTuples()); + self.assertEqual(3,coords.getNumberOfComponents()); + expected3_3=[ + 2.85,17.85,0.25,4.6,17.85,0.25,8.,17.85,0.25, 2.85,34.6,0.25,4.6,34.6,0.25,8.,34.6,0.25, + 2.85,17.85,1.225,4.6,17.85,1.225,8.,17.85,1.225, 2.85,34.6,1.225,4.6,34.6,1.225,8.,34.6,1.225, + 2.85,17.85,1.69,4.6,17.85,1.69,8.,17.85,1.69, 2.85,34.6,1.69,4.6,34.6,1.69,8.,34.6,1.69, + 2.85,17.85,2.4,4.6,17.85,2.4,8.,17.85,2.4, 2.85,34.6,2.4,4.6,34.6,2.4,8.,34.6,2.4]; + for i in xrange(72): + self.assertAlmostEqual(expected3_3[i],coords.getIJ(0,i),12); + pass + pass + + def testFieldDoubleZipCoords1(self): + m=MEDCouplingDataForTest.build2DTargetMeshMergeNode_1(); + f=m.fillFromAnalytic(ON_NODES,2,"x*2."); + f.getArray().setInfoOnComponent(0,"titi"); + f.getArray().setInfoOnComponent(1,"tutu"); + f.checkCoherency(); + self.assertEqual(18,f.getNumberOfTuples()); + self.assertEqual(2,f.getNumberOfComponents()); + expected1=[-0.6, -0.6, 0.4, 0.4, 1.4, 1.4, -0.6, -0.6, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 1.4, 1.4, -0.6, -0.6, 0.4, 0.4, 1.4, 1.4, -0.6, -0.6, 1.4, 1.4, -0.6, -0.6, 0.4, 0.4, 1.4, 1.4, 0.4, 0.4] + for i in xrange(36): + self.assertAlmostEqual(expected1[i],f.getIJ(0,i),12); + pass + self.assertTrue(f.zipCoords()); + f.checkCoherency(); + expected2=[-0.6, -0.6, 1.4, 1.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 1.4, 1.4, -0.6, -0.6, 0.4, 0.4, 1.4, 1.4, 1.4, 1.4, -0.6, -0.6, 0.4, 0.4, 1.4, 1.4, 0.4, 0.4] + for i in xrange(30): + self.assertAlmostEqual(expected2[i],f.getIJ(0,i),12); + pass + self.assertTrue(not f.zipCoords()); + f.checkCoherency(); + for i in xrange(30): + self.assertAlmostEqual(expected2[i],f.getIJ(0,i),12); + pass + self.assertTrue(f.getArray().getInfoOnComponent(0)=="titi"); + self.assertTrue(f.getArray().getInfoOnComponent(1)=="tutu"); + pass + + def testFieldDoubleZipConnectivity1(self): + m1=MEDCouplingDataForTest.build2DTargetMesh_1(); + m2=MEDCouplingDataForTest.build2DTargetMesh_1(); + cells1=[2,3,4] + m3_1=m2.buildPartOfMySelf(cells1,True); + m3=m3_1; + m4=MEDCouplingDataForTest.build2DSourceMesh_1(); + m5=MEDCouplingUMesh.mergeUMeshes(m1,m3); + m6=MEDCouplingUMesh.mergeUMeshes(m5,m4); + # + self.assertEqual(10,m6.getNumberOfCells()); + self.assertEqual(22,m6.getNumberOfNodes()); + arr,areNodesMerged,newNbOfNodes=m6.mergeNodes(1e-13); + self.assertEqual(9,m6.getNumberOfNodes()); + f=m6.fillFromAnalytic(ON_CELLS,2,"x"); + f2=m6.fillFromAnalytic(ON_NODES,2,"x"); + self.assertEqual(10,f.getNumberOfTuples()); + self.assertEqual(2,f.getNumberOfComponents()); + expected1=[-0.05, -0.05, 0.3666666666666667, 0.3666666666666667, 0.53333333333333321, 0.53333333333333321, + -0.05, -0.05, 0.45, 0.45, 0.53333333333333321, 0.53333333333333321, -0.05, -0.05, 0.45, 0.45, + 0.36666666666666659, 0.36666666666666659, 0.033333333333333326, 0.033333333333333326]; + for i in xrange(20): + self.assertAlmostEqual(expected1[i],f.getIJ(0,i),12); + pass + f.getArray().setInfoOnComponent(0,"titi"); + f.getArray().setInfoOnComponent(1,"tutu"); + f.checkCoherency(); + self.assertTrue(f.zipConnectivity(0)); + expected2=[-0.05, -0.05, 0.3666666666666667, 0.3666666666666667, 0.53333333333333321, 0.53333333333333321, + -0.05, -0.05, 0.45, 0.45, 0.36666666666666659, 0.36666666666666659, 0.033333333333333326, 0.033333333333333326]; + self.assertEqual(7,f.getNumberOfTuples()); + self.assertEqual(2,f.getNumberOfComponents()); + for i in xrange(14): + self.assertAlmostEqual(expected2[i],f.getIJ(0,i),12); + pass + self.assertTrue(f.getArray().getInfoOnComponent(0)=="titi"); + self.assertTrue(f.getArray().getInfoOnComponent(1)=="tutu"); + self.assertTrue(not f.zipConnectivity(0)); + # + expected3=[-0.3, -0.3, 0.2, 0.2, 0.7, 0.7, -0.3, -0.3, 0.2, 0.2, 0.7, 0.7, + -0.3, -0.3, 0.2, 0.2, 0.7, 0.7]; + self.assertEqual(9,f2.getNumberOfTuples()); + self.assertEqual(2,f2.getNumberOfComponents()); + for i in xrange(18): + self.assertAlmostEqual(expected3[i],f2.getIJ(0,i),12); + pass + self.assertTrue(f2.zipConnectivity(0)); + self.assertEqual(9,f2.getNumberOfTuples()); + self.assertEqual(2,f2.getNumberOfComponents()); + for i in xrange(18): + self.assertAlmostEqual(expected3[i],f2.getIJ(0,i),12); + pass + pass + + def testDaDoubleRenumber1(self): + a=DataArrayDouble.New(); + arr1=[1.1,11.1,2.1,12.1,3.1,13.1,4.1,14.1,5.1,15.1,6.1,16.1,7.1,17.1] + a.setValues(arr1,7,2); + a.setInfoOnComponent(0,"toto"); + a.setInfoOnComponent(1,"tata"); + # + arr2=[3,1,0,6,5,4,2] + b=a.renumber(arr2); + self.assertEqual(7,b.getNumberOfTuples()); + self.assertEqual(2,b.getNumberOfComponents()); + self.assertTrue(b.getInfoOnComponent(0)=="toto"); + self.assertTrue(b.getInfoOnComponent(1)=="tata"); + expected1=[3.1, 13.1, 2.1, 12.1, 7.1, 17.1, 1.1, 11.1, 6.1, 16.1, 5.1, 15.1, 4.1, 14.1] + for i in xrange(14): + self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14); + pass + # + c=DataArrayInt.New(); + arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17] + c.setValues(arr3,7,2); + c.setInfoOnComponent(0,"toto"); + c.setInfoOnComponent(1,"tata"); + d=c.renumber(arr2); + self.assertEqual(7,d.getNumberOfTuples()); + self.assertEqual(2,d.getNumberOfComponents()); + self.assertTrue(d.getInfoOnComponent(0)=="toto"); + self.assertTrue(d.getInfoOnComponent(1)=="tata"); + expected2=[3, 13, 2, 12, 7, 17, 1, 11, 6, 16, 5, 15, 4, 14] + for i in xrange(14): + self.assertEqual(expected2[i],d.getIJ(0,i)); + pass + pass + + def testDaDoubleRenumberAndReduce1(self): + a=DataArrayDouble.New(); + arr1=[1.1,11.1,2.1,12.1,3.1,13.1,4.1,14.1,5.1,15.1,6.1,16.1,7.1,17.1] + a.setValues(arr1,7,2); + a.setInfoOnComponent(0,"toto"); + a.setInfoOnComponent(1,"tata"); + # + arr2=[2,-1,1,-1,0,4,3] + b=a.renumberAndReduce(arr2,5); + self.assertEqual(5,b.getNumberOfTuples()); + self.assertEqual(2,b.getNumberOfComponents()); + self.assertTrue(b.getInfoOnComponent(0)=="toto"); + self.assertTrue(b.getInfoOnComponent(1)=="tata"); + expected1=[5.1,15.1,3.1,13.1,1.1,11.1,7.1,17.1,6.1,16.1] + for i in xrange(10): + self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14); + pass + # + c=DataArrayInt.New(); + arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17] + c.setValues(arr3,7,2); + c.setInfoOnComponent(0,"toto"); + c.setInfoOnComponent(1,"tata"); + d=c.renumberAndReduce(arr2,5); + self.assertEqual(5,d.getNumberOfTuples()); + self.assertEqual(2,d.getNumberOfComponents()); + self.assertTrue(d.getInfoOnComponent(0)=="toto"); + self.assertTrue(d.getInfoOnComponent(1)=="tata"); + expected2=[5,15,3,13,1,11,7,17,6,16] + for i in xrange(10): + self.assertEqual(expected2[i],d.getIJ(0,i)); + pass + pass + + def testDaDoubleRenumberInPlace1(self): + a=DataArrayDouble.New(); + arr1=[1.1,11.1,2.1,12.1,3.1,13.1,4.1,14.1,5.1,15.1,6.1,16.1,7.1,17.1] + a.setValues(arr1,7,2); + # + arr2=[3,1,0,6,5,4,2] + a.renumberInPlace(arr2); + self.assertEqual(7,a.getNumberOfTuples()); + self.assertEqual(2,a.getNumberOfComponents()); + expected1=[3.1, 13.1, 2.1, 12.1, 7.1, 17.1, 1.1, 11.1, 6.1, 16.1, 5.1, 15.1, 4.1, 14.1] + for i in xrange(14): + self.assertAlmostEqual(expected1[i],a.getIJ(0,i),14); + pass + # + c=DataArrayInt.New(); + arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17] + c.setValues(arr3,7,2); + c.renumberInPlace(arr2); + self.assertEqual(7,c.getNumberOfTuples()); + self.assertEqual(2,c.getNumberOfComponents()); + expected2=[3, 13, 2, 12, 7, 17, 1, 11, 6, 16, 5, 15, 4, 14] + for i in xrange(14): + self.assertEqual(expected2[i],c.getIJ(0,i)); + pass + pass + + def testDaDoubleRenumberR1(self): + a=DataArrayDouble.New(); + arr1=[1.1,11.1,2.1,12.1,3.1,13.1,4.1,14.1,5.1,15.1,6.1,16.1,7.1,17.1] + a.setValues(arr1,7,2); + a.setInfoOnComponent(0,"toto"); + a.setInfoOnComponent(1,"tata"); + # + arr2=[3,1,0,6,5,4,2] + b=a.renumberR(arr2); + self.assertEqual(7,b.getNumberOfTuples()); + self.assertEqual(2,b.getNumberOfComponents()); + self.assertTrue(b.getInfoOnComponent(0)=="toto"); + self.assertTrue(b.getInfoOnComponent(1)=="tata"); + expected1=[4.1, 14.1, 2.1, 12.1, 1.1, 11.1, 7.1, 17.1, 6.1, 16.1, 5.1, 15.1, 3.1, 13.1] + for i in xrange(14): + self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14); + pass + # + c=DataArrayInt.New(); + arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17] + c.setValues(arr3,7,2); + c.setInfoOnComponent(0,"toto"); + c.setInfoOnComponent(1,"tata"); + d=c.renumberR(arr2); + self.assertEqual(7,d.getNumberOfTuples()); + self.assertEqual(2,d.getNumberOfComponents()); + self.assertTrue(d.getInfoOnComponent(0)=="toto"); + self.assertTrue(d.getInfoOnComponent(1)=="tata"); + expected2=[4, 14, 2, 12, 1, 11, 7, 17, 6, 16, 5, 15, 3, 13] + for i in xrange(14): + self.assertEqual(expected2[i],d.getIJ(0,i)); + pass + pass + + def testDaDoubleRenumberInPlaceR1(self): + a=DataArrayDouble.New(); + arr1=[1.1,11.1,2.1,12.1,3.1,13.1,4.1,14.1,5.1,15.1,6.1,16.1,7.1,17.1] + a.setValues(arr1,7,2); + # + arr2=[3,1,0,6,5,4,2] + a.renumberInPlaceR(arr2); + self.assertEqual(7,a.getNumberOfTuples()); + self.assertEqual(2,a.getNumberOfComponents()); + expected1=[4.1, 14.1, 2.1, 12.1, 1.1, 11.1, 7.1, 17.1, 6.1, 16.1, 5.1, 15.1, 3.1, 13.1] + for i in xrange(14): + self.assertAlmostEqual(expected1[i],a.getIJ(0,i),14); + pass + # + c=DataArrayInt.New(); + arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17] + c.setValues(arr3,7,2); + c.renumberInPlaceR(arr2); + self.assertEqual(7,c.getNumberOfTuples()); + self.assertEqual(2,c.getNumberOfComponents()); + expected2=[4, 14, 2, 12, 1, 11, 7, 17, 6, 16, 5, 15, 3, 13] + for i in xrange(14): + self.assertEqual(expected2[i],c.getIJ(0,i)); + pass + pass + + def testDaDoubleSelectByTupleId1(self): + a=DataArrayDouble.New(); + arr1=[1.1,11.1,2.1,12.1,3.1,13.1,4.1,14.1,5.1,15.1,6.1,16.1,7.1,17.1] + a.setValues(arr1,7,2); + a.setInfoOnComponent(0,"toto"); + a.setInfoOnComponent(1,"tata"); + # + arr2=[4,2,0,6,5] + b=a.selectByTupleId(arr2); + self.assertEqual(5,b.getNumberOfTuples()); + self.assertEqual(2,b.getNumberOfComponents()); + self.assertTrue(b.getInfoOnComponent(0)=="toto"); + self.assertTrue(b.getInfoOnComponent(1)=="tata"); + expected1=[5.1,15.1,3.1,13.1,1.1,11.1,7.1,17.1,6.1,16.1] + for i in xrange(10): + self.assertAlmostEqual(expected1[i],b.getIJ(0,i),14); + pass + # + c=DataArrayInt.New(); + arr3=[1,11,2,12,3,13,4,14,5,15,6,16,7,17] + c.setValues(arr3,7,2); + c.setInfoOnComponent(0,"toto"); + c.setInfoOnComponent(1,"tata"); + d=c.selectByTupleId(arr2); + self.assertEqual(5,d.getNumberOfTuples()); + self.assertEqual(2,d.getNumberOfComponents()); + self.assertTrue(d.getInfoOnComponent(0)=="toto"); + self.assertTrue(d.getInfoOnComponent(1)=="tata"); + expected2=[5,15,3,13,1,11,7,17,6,16] + for i in xrange(10): + self.assertEqual(expected2[i],d.getIJ(0,i)); + pass + pass + + def testDaDoubleGetMinMaxValues1(self): + a=DataArrayDouble.New(); + arr1=[2.34,4.56,-6.77,4.55,4.56,2.24,2.34,1.02,4.56] + a.setValues(arr1,9,1); + m,where=a.getMaxValue(); + self.assertEqual(1,where); + self.assertAlmostEqual(4.56,m,12); + m,ws=a.getMaxValue2(); + self.assertAlmostEqual(4.56,m,12); + self.assertEqual(3,ws.getNumberOfTuples()); + self.assertEqual(1,ws.getNumberOfComponents()); + expected1=[1,4,8] + for i in xrange(3): + self.assertEqual(expected1[i],ws.getIJ(i,0)); + pass + a=DataArrayDouble.New(); + arr2=[-2.34,-4.56,6.77,-4.55,-4.56,-2.24,-2.34,-1.02,-4.56] + a.setValues(arr2,9,1); + m,where=a.getMinValue(); + self.assertEqual(1,where); + self.assertAlmostEqual(-4.56,m,12); + m,ws=a.getMinValue2(); + self.assertAlmostEqual(-4.56,m,12); + self.assertEqual(3,ws.getNumberOfTuples()); + self.assertEqual(1,ws.getNumberOfComponents()); + for i in xrange(3): + self.assertEqual(expected1[i],ws.getIJ(i,0)); + pass + pass + + def testFieldDoubleGetMinMaxValues2(self): + m2,m1=MEDCouplingDataForTest.build3DExtrudedUMesh_1(); + self.assertEqual(18,m2.getNumberOfCells()); + arr1=[8.71,4.53,-12.41,8.71,-8.71,8.7099,4.55,8.71,5.55,6.77,-1e-200,4.55,8.7099,0.,1.23,0.,2.22,8.71] + f=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME); + a=DataArrayDouble.New(); + a.setValues(arr1,18,1); + f.setArray(a); + f.setMesh(m2); + # + f.checkCoherency(); + m=f.getMaxValue(); + self.assertAlmostEqual(8.71,m,12); + m,ws=f.getMaxValue2(); + self.assertAlmostEqual(8.71,m,12); + self.assertEqual(4,ws.getNumberOfTuples()); + self.assertEqual(1,ws.getNumberOfComponents()); + expected1=[0,3,7,17] + for i in xrange(4): + self.assertEqual(expected1[i],ws.getIJ(i,0)); + pass + # + arr2=[-8.71,-4.53,12.41,-8.71,8.71,-8.7099,-4.55,-8.71,-5.55,-6.77,1e-200,-4.55,-8.7099,0.,-1.23,0.,-2.22,-8.71] + a.setValues(arr2,18,1); + f.checkCoherency(); + m=f.getMinValue(); + self.assertAlmostEqual(-8.71,m,12); + m,ws=f.getMinValue2(); + self.assertAlmostEqual(-8.71,m,12); + self.assertEqual(4,ws.getNumberOfTuples()); + self.assertEqual(1,ws.getNumberOfComponents()); + for i in xrange(4): + self.assertEqual(expected1[i],ws.getIJ(i,0)); + pass + pass + + def testBuildUnstructuredCMesh1(self): + m=MEDCouplingCMesh.New(); + da=DataArrayDouble.New(); + discX=[2.3,3.4,5.8,10.2] + discY=[12.3,23.4,45.8] + discZ=[-0.7,1.2,1.25,2.13,2.67] + da.setValues(discX,4,1); + m.setCoordsAt(0,da); + m.checkCoherency(); + self.assertEqual(0,m.getCellContainingPoint([2.4],12)); + self.assertEqual(1,m.getCellContainingPoint([3.7],12)); + self.assertEqual(2,m.getCellContainingPoint([5.9],12)); + self.assertEqual(-1,m.getCellContainingPoint([10.3],12)); + self.assertEqual(-1,m.getCellContainingPoint([1.3],12)); + # + m2=m.buildUnstructured(); + m2.checkCoherency(); + f1=m.getMeasureField(False); + f2=m2.getMeasureField(False); + self.assertEqual(f1.getNumberOfTuples(),3); + self.assertEqual(f2.getNumberOfTuples(),3); + self.assertEqual(1,m2.getMeshDimension()); + self.assertEqual(1,m2.getSpaceDimension()); + for i in xrange(3): + self.assertAlmostEqual(f1.getIJ(i,0),f2.getIJ(i,0),10); + pass + da=DataArrayDouble.New(); + da.setValues(discY,3,1); + m.setCoordsAt(1,da); + # + m2=m.buildUnstructured(); + m2.checkCoherency(); + f1=m.getMeasureField(False); + f2=m2.getMeasureField(False); + self.assertEqual(f1.getNumberOfTuples(),6); + self.assertEqual(f2.getNumberOfTuples(),6); + self.assertEqual(2,m2.getMeshDimension()); + self.assertEqual(2,m2.getSpaceDimension()); + for i in xrange(6): + self.assertAlmostEqual(f1.getIJ(i,0),f2.getIJ(i,0),10); + pass + # + da=DataArrayDouble.New(); + da.setValues(discZ,5,1); + m.setCoordsAt(2,da); + m2=m.buildUnstructured(); + m2.checkCoherency(); + f1=m.getMeasureField(False); + f2=m2.getMeasureField(False); + self.assertEqual(f1.getNumberOfTuples(),24); + self.assertEqual(f2.getNumberOfTuples(),24); + self.assertEqual(3,m2.getMeshDimension()); + self.assertEqual(3,m2.getSpaceDimension()); + for i in xrange(24): + self.assertAlmostEqual(f1.getIJ(i,0),f2.getIJ(i,0),10); + pass + # + pos1=[5.,30.,2.] + self.assertEqual(16,m.getCellContainingPoint(pos1,1e-12)); + # + pt=[2.4,12.7,-3.4] + m.scale(pt,3.7); + m3=m.buildUnstructured(); + m2.scale(pt,3.7); + self.assertTrue(m3.isEqual(m2,1e-12)); + pass + + def testDataArrayIntInvertO2NNO21(self): + arr1=[2,0,4,1,5,3] + da=DataArrayInt.New(); + da.setValues(arr1,6,1); + da2=da.invertArrayO2N2N2O(6); + self.assertEqual(6,da2.getNumberOfTuples()); + self.assertEqual(1,da2.getNumberOfComponents()); + expected1=[1,3,0,5,2,4] + for i in xrange(6): + self.assertEqual(expected1[i],da2.getIJ(i,0)); + pass + da3=da2.invertArrayN2O2O2N(6); + for i in xrange(6): + self.assertEqual(arr1[i],da3.getIJ(i,0)); + pass + # + arr2=[3,-1,5,4,-1,0,-1,1,2,-1] + da=DataArrayInt.New(); + da.setValues(arr2,10,1); + da2=da.invertArrayO2N2N2O(6); + self.assertEqual(6,da2.getNumberOfTuples()); + self.assertEqual(1,da2.getNumberOfComponents()); + expected2=[5,7,8,0,3,2] + for i in xrange(6): + self.assertEqual(expected2[i],da2.getIJ(i,0)); + pass + da3=da2.invertArrayN2O2O2N(10); + for i in xrange(10): + self.assertEqual(arr2[i],da3.getIJ(i,0)); + pass + pass def setUp(self): pass diff --git a/src/MEDCoupling_Swig/libMEDCoupling_Swig.i b/src/MEDCoupling_Swig/libMEDCoupling_Swig.i index 48a7115d9..f6d3f696e 100644 --- a/src/MEDCoupling_Swig/libMEDCoupling_Swig.i +++ b/src/MEDCoupling_Swig/libMEDCoupling_Swig.i @@ -98,6 +98,11 @@ using namespace INTERP_KERNEL; %newobject ParaMEDMEM::DataArrayInt::substr; %newobject ParaMEDMEM::DataArrayInt::changeNbOfComponents; %newobject ParaMEDMEM::DataArrayInt::selectByTupleId; +%newobject ParaMEDMEM::DataArrayInt::renumber; +%newobject ParaMEDMEM::DataArrayInt::renumberR; +%newobject ParaMEDMEM::DataArrayInt::renumberAndReduce; +%newobject ParaMEDMEM::DataArrayInt::invertArrayO2N2N2O; +%newobject ParaMEDMEM::DataArrayInt::invertArrayN2O2O2N; %newobject ParaMEDMEM::DataArrayDouble::aggregate; %newobject ParaMEDMEM::DataArrayDouble::dot; %newobject ParaMEDMEM::DataArrayDouble::crossProduct; @@ -119,6 +124,9 @@ using namespace INTERP_KERNEL; %newobject ParaMEDMEM::DataArrayDouble::deviator; %newobject ParaMEDMEM::DataArrayDouble::magnitude; %newobject ParaMEDMEM::DataArrayDouble::maxPerTuple; +%newobject ParaMEDMEM::DataArrayDouble::renumber; +%newobject ParaMEDMEM::DataArrayDouble::renumberR; +%newobject ParaMEDMEM::DataArrayDouble::renumberAndReduce; %newobject ParaMEDMEM::MEDCouplingFieldDouble::clone; %newobject ParaMEDMEM::MEDCouplingFieldDouble::cloneWithMesh; %newobject ParaMEDMEM::MEDCouplingFieldDouble::buildNewTimeReprFromThis; @@ -148,6 +156,7 @@ using namespace INTERP_KERNEL; %newobject ParaMEDMEM::MEDCouplingExtrudedMesh::New; %newobject ParaMEDMEM::MEDCouplingExtrudedMesh::build3DUnstructuredMesh; %newobject ParaMEDMEM::MEDCouplingCMesh::New; +%newobject ParaMEDMEM::MEDCouplingCMesh::buildUnstructured; %feature("unref") DataArrayDouble "$this->decrRef();" %feature("unref") MEDCouplingPointSet "$this->decrRef();" %feature("unref") MEDCouplingMesh "$this->decrRef();" @@ -158,7 +167,7 @@ using namespace INTERP_KERNEL; %feature("unref") MEDCouplingField "$this->decrRef();" %feature("unref") MEDCouplingFieldDouble "$this->decrRef();" -%ignore ParaMEDMEM::TimeLabel::operator=; +%rename(assign) *::operator=; %ignore ParaMEDMEM::MemArray::operator=; %ignore ParaMEDMEM::MemArray::operator[]; %ignore ParaMEDMEM::MEDCouplingPointSet::getCoords(); @@ -166,6 +175,7 @@ using namespace INTERP_KERNEL; %ignore ParaMEDMEM::MEDCouplingGaussLocalization::pushTinySerializationDblInfo; %ignore ParaMEDMEM::MEDCouplingGaussLocalization::fillWithValues; %ignore ParaMEDMEM::MEDCouplingGaussLocalization::buildNewInstanceFromTinyInfo; + %rename (Exception) InterpKernelException; %nodefaultctor; @@ -221,7 +231,6 @@ namespace ParaMEDMEM virtual void getBoundingBox(double *bbox) const = 0; virtual MEDCouplingFieldDouble *getMeasureField(bool isAbs) const = 0; virtual MEDCouplingFieldDouble *getMeasureFieldOnNode(bool isAbs) const = 0; - virtual int getCellContainingPoint(const double *pos, double eps) const = 0; virtual MEDCouplingFieldDouble *fillFromAnalytic(TypeOfField t, int nbOfComp, const char *func) const throw(INTERP_KERNEL::Exception); virtual MEDCouplingFieldDouble *buildOrthogonalField() const = 0; virtual void rotate(const double *center, const double *vector, double angle) = 0; @@ -237,6 +246,15 @@ namespace ParaMEDMEM return self->simpleRepr(); } + int getCellContainingPoint(PyObject *p, double eps) const + { + int sz; + double *pos=convertPyToNewDblArr2(p,&sz); + int ret=self->getCellContainingPoint(pos,eps); + delete [] pos; + return ret; + } + void renumberCells(PyObject *li, bool check) throw(INTERP_KERNEL::Exception) { int size; @@ -492,15 +510,6 @@ namespace ParaMEDMEM { return self->simpleRepr(); } - - int getCellContainingPoint(PyObject *p, double eps) const - { - int sz; - double *pos=convertPyToNewDblArr2(p,&sz); - int ret=self->getCellContainingPoint(pos,eps); - delete [] pos; - return ret; - } void insertNextCell(INTERP_KERNEL::NormalizedCellType type, int size, PyObject *li) { int sz; @@ -732,6 +741,7 @@ namespace ParaMEDMEM DataArrayDouble *coordsY=0, DataArrayDouble *coordsZ=0); void setCoordsAt(int i, DataArrayDouble *arr) throw(INTERP_KERNEL::Exception); + MEDCouplingUMesh *buildUnstructured() const; %extend { std::string __str__() const { @@ -768,6 +778,123 @@ namespace ParaMEDMEM int nbOfTuples=self->getNumberOfTuples(); return convertDblArrToPyListOfTuple(vals,nbOfComp,nbOfTuples); } + + DataArrayDouble *renumber(PyObject *li) throw(INTERP_KERNEL::Exception) + { + int size; + int *tmp=convertPyToNewIntArr2(li,&size); + if(size!=self->getNumberOfTuples()) + { + throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !"); + delete [] tmp; + } + DataArrayDouble *ret=self->renumber(tmp); + delete [] tmp; + return ret; + } + + DataArrayDouble *renumberR(PyObject *li) throw(INTERP_KERNEL::Exception) + { + int size; + int *tmp=convertPyToNewIntArr2(li,&size); + if(size!=self->getNumberOfTuples()) + { + throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !"); + delete [] tmp; + } + DataArrayDouble *ret=self->renumberR(tmp); + delete [] tmp; + return ret; + } + + DataArrayDouble *renumberAndReduce(PyObject *li, int newNbOfTuple) throw(INTERP_KERNEL::Exception) + { + int size; + int *tmp=convertPyToNewIntArr2(li,&size); + if(size!=self->getNumberOfTuples()) + { + throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !"); + delete [] tmp; + } + DataArrayDouble *ret=self->renumberAndReduce(tmp,newNbOfTuple); + delete [] tmp; + return ret; + } + + void renumberInPlace(PyObject *li) throw(INTERP_KERNEL::Exception) + { + int size; + int *tmp=convertPyToNewIntArr2(li,&size); + if(size!=self->getNumberOfTuples()) + { + throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !"); + delete [] tmp; + } + self->renumberInPlace(tmp); + delete [] tmp; + } + + void renumberInPlaceR(PyObject *li) throw(INTERP_KERNEL::Exception) + { + int size; + int *tmp=convertPyToNewIntArr2(li,&size); + if(size!=self->getNumberOfTuples()) + { + throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !"); + delete [] tmp; + } + self->renumberInPlaceR(tmp); + delete [] tmp; + } + + DataArrayDouble *selectByTupleId(PyObject *li) const + { + int size; + int *tmp=convertPyToNewIntArr2(li,&size); + DataArrayDouble *ret=self->selectByTupleId(tmp,tmp+size); + delete [] tmp; + return ret; + } + + PyObject *getMaxValue() const throw(INTERP_KERNEL::Exception) + { + int tmp; + double r1=self->getMaxValue(tmp); + PyObject *ret=PyTuple_New(2); + PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1)); + PyTuple_SetItem(ret,1,PyInt_FromLong(tmp)); + return ret; + } + + PyObject *getMaxValue2() const throw(INTERP_KERNEL::Exception) + { + DataArrayInt *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_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 )); + return ret; + } + + PyObject *getMinValue() const throw(INTERP_KERNEL::Exception) + { + int tmp; + double r1=self->getMinValue(tmp); + PyObject *ret=PyTuple_New(2); + PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1)); + PyTuple_SetItem(ret,1,PyInt_FromLong(tmp)); + return ret; + } + + PyObject *getMinValue2() const throw(INTERP_KERNEL::Exception) + { + DataArrayInt *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_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 )); + return ret; + } }; %extend ParaMEDMEM::DataArrayInt @@ -813,6 +940,83 @@ namespace ParaMEDMEM PyList_SetItem(ret,1,ret1); return ret; } + + void renumberInPlace(PyObject *li) throw(INTERP_KERNEL::Exception) + { + int size; + int *tmp=convertPyToNewIntArr2(li,&size); + if(size!=self->getNumberOfTuples()) + { + throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !"); + delete [] tmp; + } + self->renumberInPlace(tmp); + delete [] tmp; + } + + void renumberInPlaceR(PyObject *li) throw(INTERP_KERNEL::Exception) + { + int size; + int *tmp=convertPyToNewIntArr2(li,&size); + if(size!=self->getNumberOfTuples()) + { + throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !"); + delete [] tmp; + } + self->renumberInPlaceR(tmp); + delete [] tmp; + } + + DataArrayInt *renumberAndReduce(PyObject *li, int newNbOfTuple) throw(INTERP_KERNEL::Exception) + { + int size; + int *tmp=convertPyToNewIntArr2(li,&size); + if(size!=self->getNumberOfTuples()) + { + throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !"); + delete [] tmp; + } + DataArrayInt *ret=self->renumberAndReduce(tmp,newNbOfTuple); + delete [] tmp; + return ret; + } + + DataArrayInt *renumber(PyObject *li) throw(INTERP_KERNEL::Exception) + { + int size; + int *tmp=convertPyToNewIntArr2(li,&size); + if(size!=self->getNumberOfTuples()) + { + throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !"); + delete [] tmp; + } + DataArrayInt *ret=self->renumber(tmp); + delete [] tmp; + return ret; + } + + DataArrayInt *renumberR(PyObject *li) throw(INTERP_KERNEL::Exception) + { + int size; + int *tmp=convertPyToNewIntArr2(li,&size); + if(size!=self->getNumberOfTuples()) + { + throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !"); + delete [] tmp; + } + DataArrayInt *ret=self->renumberR(tmp); + delete [] tmp; + return ret; + } + + DataArrayInt *selectByTupleId(PyObject *li) const + { + int size; + int *tmp=convertPyToNewIntArr2(li,&size); + DataArrayInt *ret=self->selectByTupleId(tmp,tmp+size); + delete [] tmp; + return ret; + } }; namespace ParaMEDMEM @@ -915,6 +1119,8 @@ namespace ParaMEDMEM void changeUnderlyingMesh(const MEDCouplingMesh *other, int levOfCheck, double prec) throw(INTERP_KERNEL::Exception); void substractInPlaceDM(const MEDCouplingFieldDouble *f, int levOfCheck, double prec) throw(INTERP_KERNEL::Exception); bool mergeNodes(double eps) throw(INTERP_KERNEL::Exception); + bool zipCoords() throw(INTERP_KERNEL::Exception); + bool zipConnectivity(int compType) 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); @@ -926,6 +1132,8 @@ namespace ParaMEDMEM 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 char *func) throw(INTERP_KERNEL::Exception); void applyFunc(int nbOfComp, const char *func) throw(INTERP_KERNEL::Exception); void applyFunc(const char *func) throw(INTERP_KERNEL::Exception); void applyFuncFast32(const char *func) throw(INTERP_KERNEL::Exception); @@ -1051,7 +1259,7 @@ namespace ParaMEDMEM } PyObject *accumulate() const { - int sz=self->getNumberOfTuples(); + int sz=self->getNumberOfComponents(); double *tmp=new double[sz]; self->accumulate(tmp); PyObject *ret=convertDblArrToPyList(tmp,sz); @@ -1060,7 +1268,7 @@ namespace ParaMEDMEM } PyObject *integral(bool isWAbs) const { - int sz=self->getNumberOfTuples(); + int sz=self->getNumberOfComponents(); double *tmp=new double[sz]; self->integral(isWAbs,tmp); PyObject *ret=convertDblArrToPyList(tmp,sz); @@ -1069,7 +1277,7 @@ namespace ParaMEDMEM } PyObject *normL1() const throw(INTERP_KERNEL::Exception) { - int sz=self->getNumberOfTuples(); + int sz=self->getNumberOfComponents(); double *tmp=new double[sz]; self->normL1(tmp); PyObject *ret=convertDblArrToPyList(tmp,sz); @@ -1078,7 +1286,7 @@ namespace ParaMEDMEM } PyObject *normL2() const throw(INTERP_KERNEL::Exception) { - int sz=self->getNumberOfTuples(); + int sz=self->getNumberOfComponents(); double *tmp=new double[sz]; self->normL2(tmp); PyObject *ret=convertDblArrToPyList(tmp,sz); @@ -1134,6 +1342,26 @@ namespace ParaMEDMEM delete [] tmp; return ret; } + + PyObject *getMaxValue2() const throw(INTERP_KERNEL::Exception) + { + DataArrayInt *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_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 )); + return ret; + } + + PyObject *getMinValue2() const throw(INTERP_KERNEL::Exception) + { + DataArrayInt *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_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 )); + return ret; + } } }; } diff --git a/src/MEDLoader/Swig/MEDLoaderTest.py b/src/MEDLoader/Swig/MEDLoaderTest.py index ad9472fd1..2d566c0e7 100644 --- a/src/MEDLoader/Swig/MEDLoaderTest.py +++ b/src/MEDLoader/Swig/MEDLoaderTest.py @@ -388,6 +388,69 @@ class MEDLoaderTest(unittest.TestCase): self.assertTrue(f2.isEqual(f1,1e-12,1e-12)); pass + def testFieldNodeProfilRW1(self): + fileName="Pyfile19.med"; + fileName2="Pyfile20.med"; + m=MEDLoaderDataForTest.build2DMesh_1(); + nbOfNodes=m.getNumberOfNodes(); + MEDLoader.WriteUMesh(fileName,m,True); + f1=MEDCouplingFieldDouble.New(ON_NODES,ONE_TIME); + f1.setName("VFieldOnNodes"); + f1.setMesh(m); + array=DataArrayDouble.New(); + arr1=[1.,101.,2.,102.,3.,103.,4.,104.,5.,105.,6.,106.,7.,107.,8.,108.,9.,109.,10.,110.,11.,111.,12.,112.] + array.setValues(arr1,nbOfNodes,2); + f1.setArray(array); + array.setInfoOnComponent(0,"tyty (mm)"); + array.setInfoOnComponent(1,"uiop (MW)"); + f1.setTime(3.14,2,7); + f1.checkCoherency(); + arr2=[2,4,5,3,6,7] + f2=f1.buildSubPart(arr2); + f2.getMesh().setName(f1.getMesh().getName()); + MEDLoader.WriteField(fileName,f2,False);#<- False important for the test + # + f3=MEDLoader.ReadFieldNode(fileName,f2.getMesh().getName(),0,f2.getName(),2,7); + f3.checkCoherency(); + self.assertTrue(f3.isEqual(f2,1e-12,1e-12)); + # + arr3=[1,3,0,5,2,4] + f2.renumberNodes(arr3); + MEDLoader.WriteUMesh(fileName2,m,True); + MEDLoader.WriteField(fileName2,f2,False);#<- False important for the test + f3=MEDLoader.ReadFieldNode(fileName2,f2.getMesh().getName(),0,f2.getName(),2,7); + f3.checkCoherency(); + self.assertTrue(f3.isEqual(f2,1e-12,1e-12)); + # + pass + + def testFieldNodeProfilRW2(self): + fileName="Pyfile23.med"; + mesh=MEDLoaderDataForTest.build3DSurfMesh_1(); + MEDLoader.WriteUMesh(fileName,mesh,True); + # + f1=MEDCouplingFieldDouble.New(ON_NODES,ONE_TIME); + f1.setName("FieldMix"); + f1.setMesh(mesh); + arr2=[1071.,1171.,1010.,1110.,1020.,1120.,1030.,1130.,1040.,1140.,1050.,1150., + 1060.,1160.,1070.,1170.,1080.,1180.,1090.,1190.,1091.,1191.,1092.,1192.]; + array=DataArrayDouble.New(); + array.setValues(arr2,12,2); + f1.setArray(array); + array.setInfoOnComponent(0,"plkj (mm)"); + array.setInfoOnComponent(1,"pqqqss (mm)"); + tmp=array.getPointer(); + f1.setTime(3.17,2,7); + # + renumArr=[3,7,2,1,5,11,10,0,9,6,8,4] + f1.renumberNodes(renumArr); + f1.checkCoherency(); + MEDLoader.WriteField(fileName,f1,False);#<- False important for the test + f2=MEDLoader.ReadFieldNode(fileName,f1.getMesh().getName(),0,f1.getName(),2,7); + self.assertTrue(f2.isEqual(f1,1e-12,1e-12)); + # + pass + def testMixCellAndNodesFieldRW1(self): fileName="Pyfile21.med"; mesh=MEDLoaderDataForTest.build3DSurfMesh_1(); @@ -439,6 +502,37 @@ class MEDLoaderTest(unittest.TestCase): self.assertTrue(f3.isEqual(f1,1e-12,1e-12)); # pass + + def testGetAllFieldNamesRW1(self): + fileName="Pyfile22.med"; + mesh=MEDLoaderDataForTest.build2DMesh_2(); + f1=MEDCouplingFieldDouble.New(ON_NODES,ONE_TIME); + f1.setName("Field1"); + f1.setTime(3.44,5,6); + f1.setMesh(mesh); + f1.fillFromAnalytic(2,"x+y"); + MEDLoader.WriteField(fileName,f1,True); + f1.setTime(1002.3,7,8); + f1.fillFromAnalytic(2,"x+77.*y"); + MEDLoader.WriteFieldUsingAlreadyWrittenMesh(fileName,f1); + f1.setName("Field2"); + MEDLoader.WriteField(fileName,f1,False); + f1.setName("Field3"); + mesh.setName("2DMesh_2Bis"); + MEDLoader.WriteField(fileName,f1,False); + f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME); + f1.setName("Field8"); + f1.setTime(8.99,7,9); + f1.setMesh(mesh); + f1.fillFromAnalytic(3,"3*x+y"); + MEDLoader.WriteField(fileName,f1,False); + fs=MEDLoader.GetAllFieldNames(fileName); + self.assertEqual(4,len(fs)); + self.assertTrue(fs[0]=="Field1"); + self.assertTrue(fs[1]=="Field2"); + self.assertTrue(fs[2]=="Field3"); + self.assertTrue(fs[3]=="Field8"); + pass pass unittest.main() diff --git a/src/MEDLoader/Swig/libMEDLoader_Swig.i b/src/MEDLoader/Swig/libMEDLoader_Swig.i index f9144f47f..9ab3b1423 100644 --- a/src/MEDLoader/Swig/libMEDLoader_Swig.i +++ b/src/MEDLoader/Swig/libMEDLoader_Swig.i @@ -53,6 +53,7 @@ public: static std::vector GetMeshGroupsNames(const char *fileName, const char *meshName) throw(INTERP_KERNEL::Exception); static std::vector GetMeshFamiliesNames(const char *fileName, const char *meshName) throw(INTERP_KERNEL::Exception); static std::vector GetAllFieldNamesOnMesh(const char *fileName, const char *meshName) throw(INTERP_KERNEL::Exception); + static std::vector GetAllFieldNames(const char *fileName) throw(INTERP_KERNEL::Exception); static std::vector GetFieldNamesOnMesh(ParaMEDMEM::TypeOfField type, const char *fileName, const char *meshName) throw(INTERP_KERNEL::Exception); static std::vector GetCellFieldNamesOnMesh(const char *fileName, const char *meshName) throw(INTERP_KERNEL::Exception); static std::vector GetNodeFieldNamesOnMesh(const char *fileName, const char *meshName) throw(INTERP_KERNEL::Exception); diff --git a/src/MEDLoader/Test/MEDLoaderTest.cxx b/src/MEDLoader/Test/MEDLoaderTest.cxx index a62bc1be3..ab58c843a 100644 --- a/src/MEDLoader/Test/MEDLoaderTest.cxx +++ b/src/MEDLoader/Test/MEDLoaderTest.cxx @@ -406,9 +406,9 @@ void MEDLoaderTest::testFieldNodeProfilRW1() f2->renumberNodes(arr3); MEDLoader::WriteUMesh(fileName2,m,true); MEDLoader::WriteField(fileName2,f2,false);//<- false important for the test - f3=MEDLoader::ReadFieldNode(fileName,f2->getMesh()->getName(),0,f2->getName(),2,7); + f3=MEDLoader::ReadFieldNode(fileName2,f2->getMesh()->getName(),0,f2->getName(),2,7); f3->checkCoherency(); - //CPPUNIT_ASSERT(f3->isEqual(f2,1e-12,1e-12));//<- bug + CPPUNIT_ASSERT(f3->isEqual(f2,1e-12,1e-12)); f3->decrRef(); f2->decrRef(); // @@ -416,6 +416,41 @@ void MEDLoaderTest::testFieldNodeProfilRW1() m->decrRef(); } +void MEDLoaderTest::testFieldNodeProfilRW2() +{ + const char fileName[]="file23.med"; + MEDCouplingUMesh *mesh=build3DSurfMesh_1(); + MEDLoader::WriteUMesh(fileName,mesh,true); + // + MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_NODES,ONE_TIME); + f1->setName("FieldMix"); + f1->setMesh(mesh); + const double arr2[24]={ + 1071.,1171.,1010.,1110.,1020.,1120.,1030.,1130.,1040.,1140.,1050.,1150., + 1060.,1160.,1070.,1170.,1080.,1180.,1090.,1190.,1091.,1191.,1092.,1192. + }; + DataArrayDouble *array=DataArrayDouble::New(); + array->alloc(12,2); + f1->setArray(array); + array->setInfoOnComponent(0,"plkj (mm)"); + array->setInfoOnComponent(1,"pqqqss (mm)"); + array->decrRef(); + double *tmp=array->getPointer(); + std::copy(arr2,arr2+24,tmp); + f1->setTime(3.17,2,7); + // + const int renumArr[12]={3,7,2,1,5,11,10,0,9,6,8,4}; + f1->renumberNodes(renumArr); + f1->checkCoherency(); + MEDLoader::WriteField(fileName,f1,false);//<- false important for the test + MEDCouplingFieldDouble *f2=MEDLoader::ReadFieldNode(fileName,f1->getMesh()->getName(),0,f1->getName(),2,7); + CPPUNIT_ASSERT(f2->isEqual(f1,1e-12,1e-12)); + // + f2->decrRef(); + mesh->decrRef(); + f1->decrRef(); +} + void MEDLoaderTest::testFieldGaussRW1() { const char fileName[]="file13.med"; @@ -654,6 +689,41 @@ void MEDLoaderTest::testMixCellAndNodesFieldRW1() mesh->decrRef(); } +void MEDLoaderTest::testGetAllFieldNamesRW1() +{ + const char fileName[]="file22.med"; + MEDCouplingUMesh *mesh=build2DMesh_2(); + MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_NODES,ONE_TIME); + f1->setName("Field1"); + f1->setTime(3.44,5,6); + f1->setMesh(mesh); + f1->fillFromAnalytic(2,"x+y"); + MEDLoader::WriteField(fileName,f1,true); + f1->setTime(1002.3,7,8); + f1->fillFromAnalytic(2,"x+77.*y"); + MEDLoader::WriteFieldUsingAlreadyWrittenMesh(fileName,f1); + f1->setName("Field2"); + MEDLoader::WriteField(fileName,f1,false); + f1->setName("Field3"); + mesh->setName("2DMesh_2Bis"); + MEDLoader::WriteField(fileName,f1,false); + f1->decrRef(); + f1=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME); + f1->setName("Field8"); + f1->setTime(8.99,7,9); + f1->setMesh(mesh); + f1->fillFromAnalytic(3,"3*x+y"); + MEDLoader::WriteField(fileName,f1,false); + f1->decrRef(); + std::vector fs=MEDLoader::GetAllFieldNames(fileName); + CPPUNIT_ASSERT_EQUAL(4,(int)fs.size()); + CPPUNIT_ASSERT(fs[0]=="Field1"); + CPPUNIT_ASSERT(fs[1]=="Field2"); + CPPUNIT_ASSERT(fs[2]=="Field3"); + CPPUNIT_ASSERT(fs[3]=="Field8"); + mesh->decrRef(); +} + MEDCouplingUMesh *MEDLoaderTest::build1DMesh_1() { double coords[6]={ 0.0, 0.3, 0.75, 1.0, 1.4, 1.3 }; diff --git a/src/MEDLoader/Test/MEDLoaderTest.hxx b/src/MEDLoader/Test/MEDLoaderTest.hxx index 0863ad1df..aa17ea35f 100644 --- a/src/MEDLoader/Test/MEDLoaderTest.hxx +++ b/src/MEDLoader/Test/MEDLoaderTest.hxx @@ -41,6 +41,7 @@ namespace ParaMEDMEM CPPUNIT_TEST( testMultiMeshRW1 ); CPPUNIT_TEST( testFieldProfilRW1 ); CPPUNIT_TEST( testFieldNodeProfilRW1 ); + CPPUNIT_TEST( testFieldNodeProfilRW2 ); CPPUNIT_TEST( testFieldGaussRW1 ); CPPUNIT_TEST( testFieldGaussNERW1 ); CPPUNIT_TEST( testLittleStrings1 ); @@ -49,6 +50,7 @@ namespace ParaMEDMEM CPPUNIT_TEST( testMultiFieldShuffleRW1 ); CPPUNIT_TEST( testWriteUMeshesRW1 ); CPPUNIT_TEST( testMixCellAndNodesFieldRW1 ); + CPPUNIT_TEST( testGetAllFieldNamesRW1 ); CPPUNIT_TEST_SUITE_END(); public: void testMesh1DRW(); @@ -62,6 +64,7 @@ namespace ParaMEDMEM void testMultiMeshRW1(); void testFieldProfilRW1(); void testFieldNodeProfilRW1(); + void testFieldNodeProfilRW2(); void testFieldGaussRW1(); void testFieldGaussNERW1(); void testLittleStrings1(); @@ -70,6 +73,7 @@ namespace ParaMEDMEM void testMultiFieldShuffleRW1(); void testWriteUMeshesRW1(); void testMixCellAndNodesFieldRW1(); + void testGetAllFieldNamesRW1(); private: MEDCouplingUMesh *build1DMesh_1(); MEDCouplingUMesh *build2DCurveMesh_1(); -- 2.39.2