STRING(TOUPPER ${PROJECT_NAME} PROJECT_NAME_UC)
SET(${PROJECT_NAME_UC}_MAJOR_VERSION 8)
- SET(${PROJECT_NAME_UC}_MINOR_VERSION 2)
+ SET(${PROJECT_NAME_UC}_MINOR_VERSION 3)
SET(${PROJECT_NAME_UC}_PATCH_VERSION 0)
SET(${PROJECT_NAME_UC}_VERSION
${${PROJECT_NAME_UC}_MAJOR_VERSION}.${${PROJECT_NAME_UC}_MINOR_VERSION}.${${PROJECT_NAME_UC}_PATCH_VERSION})
SALOME_LOG_OPTIONAL_PACKAGE(PythonInterp MEDCOUPLING_ENABLE_PYTHON)
SALOME_LOG_OPTIONAL_PACKAGE(PythonLibs MEDCOUPLING_ENABLE_PYTHON)
SALOME_LOG_OPTIONAL_PACKAGE(SWIG MEDCOUPLING_ENABLE_PYTHON)
+ IF ("${PYTHON_VERSION_MAJOR}" STREQUAL "2")
+ IF("${PYTHON_VERSION_MINOR}" LESS "7")
+ MESSAGE(FATAL_ERROR "MEDCoupling's Python requires at least Python 2.7 (you seem to have ${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR}). Upgrade your Python, or turn off MEDCOUPLING_ENABLE_PYTHON")
+ ENDIF()
+ ENDIF()
+ IF ("${PYTHON_VERSION_MAJOR}" STREQUAL "3")
+ MESSAGE(STATUS "Using Python 3")
+ ENDIF()
ENDIF(MEDCOUPLING_ENABLE_PYTHON)
IF(MEDCOUPLING_BUILD_DOC)
#include "InterpKernelGeo2DEdgeLin.hxx"
#include "InterpKernelGeo2DEdgeArcCircle.hxx"
#include "InterpKernelGeo2DQuadraticPolygon.hxx"
+#include "OrientationInverter.hxx"
#include "MEDCouplingUMesh_internal.hxx"
#include <sstream>
void MEDCouplingUMesh::getReverseNodalConnectivity(DataArrayInt *revNodal, DataArrayInt *revNodalIndx) const
{
checkFullyDefined();
- int nbOfNodes=getNumberOfNodes();
+ int nbOfNodes(getNumberOfNodes());
int *revNodalIndxPtr=(int *)malloc((nbOfNodes+1)*sizeof(int));
revNodalIndx->useArray(revNodalIndxPtr,true,C_DEALLOC,nbOfNodes+1,1);
std::fill(revNodalIndxPtr,revNodalIndxPtr+nbOfNodes+1,0);
- const int *conn=_nodal_connec->getConstPointer();
- const int *connIndex=_nodal_connec_index->getConstPointer();
- int nbOfCells=getNumberOfCells();
- int nbOfEltsInRevNodal=0;
+ const int *conn(_nodal_connec->begin()),*connIndex(_nodal_connec_index->begin());
+ int nbOfCells(getNumberOfCells()),nbOfEltsInRevNodal(0);
for(int eltId=0;eltId<nbOfCells;eltId++)
{
- const int *strtNdlConnOfCurCell=conn+connIndex[eltId]+1;
- const int *endNdlConnOfCurCell=conn+connIndex[eltId+1];
+ const int *strtNdlConnOfCurCell(conn+connIndex[eltId]+1),*endNdlConnOfCurCell(conn+connIndex[eltId+1]);
for(const int *iter=strtNdlConnOfCurCell;iter!=endNdlConnOfCurCell;iter++)
if(*iter>=0)//for polyhedrons
{
{
if(!desc || !descIndx || !revDesc || !revDescIndx)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::ComputeNeighborsOfCellsAdv some input array is empty !");
- const int *descPtr=desc->getConstPointer();
- const int *descIPtr=descIndx->getConstPointer();
- const int *revDescPtr=revDesc->getConstPointer();
- const int *revDescIPtr=revDescIndx->getConstPointer();
+ const int *descPtr=desc->begin();
+ const int *descIPtr=descIndx->begin();
+ const int *revDescPtr=revDesc->begin();
+ const int *revDescIPtr=revDescIndx->begin();
//
int nbCells=descIndx->getNumberOfTuples()-1;
MCAuto<DataArrayInt> out0=DataArrayInt::New();
neighborsIndx=out1.retn();
}
+/*!
+ * Explodes \a this into edges whatever its dimension.
+ */
+MCAuto<MEDCouplingUMesh> MEDCouplingUMesh::explodeIntoEdges(MCAuto<DataArrayInt>& desc, MCAuto<DataArrayInt>& descIndex, MCAuto<DataArrayInt>& revDesc, MCAuto<DataArrayInt>& revDescIndx) const
+{
+ checkFullyDefined();
+ int mdim(getMeshDimension());
+ desc=DataArrayInt::New(); descIndex=DataArrayInt::New(); revDesc=DataArrayInt::New(); revDescIndx=DataArrayInt::New();
+ MCAuto<MEDCouplingUMesh> mesh1D;
+ switch(mdim)
+ {
+ case 3:
+ {
+ mesh1D=explode3DMeshTo1D(desc,descIndex,revDesc,revDescIndx);
+ break;
+ }
+ case 2:
+ {
+ mesh1D=buildDescendingConnectivity(desc,descIndex,revDesc,revDescIndx);
+ break;
+ }
+ default:
+ {
+ throw INTERP_KERNEL::Exception("MEDCouplingUMesh::computeNeighborsOfNodes : Mesh dimension supported are [3,2] !");
+ }
+ }
+ return mesh1D;
+}
+
/*!
* \b WARNING this method do the assumption that connectivity lies on the coordinates set.
* For speed reasons no check of this will be done. This method calls
* The number of tuples is equal to the last values in \b neighborsIndx.
* \param [out] neighborsIdx is an array of size this->getNumberOfCells()+1 newly allocated and should
* be dealt by the caller. This arrays allow to use the first output parameter \b neighbors.
+ *
+ * \sa MEDCouplingUMesh::computeEnlargedNeighborsOfNodes
*/
void MEDCouplingUMesh::computeNeighborsOfNodes(DataArrayInt *&neighbors, DataArrayInt *&neighborsIdx) const
{
checkFullyDefined();
int mdim(getMeshDimension()),nbNodes(getNumberOfNodes());
MCAuto<DataArrayInt> desc(DataArrayInt::New()),descIndx(DataArrayInt::New()),revDesc(DataArrayInt::New()),revDescIndx(DataArrayInt::New());
- MCAuto<MEDCouplingUMesh> mesh1D;
+ MCConstAuto<MEDCouplingUMesh> mesh1D;
switch(mdim)
{
case 3:
}
case 1:
{
- mesh1D=const_cast<MEDCouplingUMesh *>(this);
- mesh1D->incrRef();
+ mesh1D.takeRef(this);
break;
}
default:
neighborsIdx=descIndx.retn();
}
+/*!
+ * Computes enlarged neighbors for each nodes in \a this. The behavior of this method is close to MEDCouplingUMesh::computeNeighborsOfNodes except that the neighborhood of each node is wider here.
+ * A node j is considered to be in the neighborhood of i if and only if there is a cell in \a this containing in its nodal connectivity both i and j.
+ * This method is useful to find ghost cells of a part of a mesh with a code based on fields on nodes.
+ *
+ * \sa MEDCouplingUMesh::computeNeighborsOfNodes
+ */
+void MEDCouplingUMesh::computeEnlargedNeighborsOfNodes(MCAuto<DataArrayInt> &neighbors, MCAuto<DataArrayInt>& neighborsIdx) const
+{
+ checkFullyDefined();
+ int nbOfNodes(getNumberOfNodes());
+ const int *conn(_nodal_connec->begin()),*connIndex(_nodal_connec_index->begin());
+ int nbOfCells(getNumberOfCells());
+ std::vector< std::set<int> > st0(nbOfNodes);
+ for(int eltId=0;eltId<nbOfCells;eltId++)
+ {
+ const int *strtNdlConnOfCurCell(conn+connIndex[eltId]+1),*endNdlConnOfCurCell(conn+connIndex[eltId+1]);
+ std::set<int> s(strtNdlConnOfCurCell,endNdlConnOfCurCell); s.erase(-1); //for polyhedrons
+ for(std::set<int>::const_iterator iter2=s.begin();iter2!=s.end();iter2++)
+ st0[*iter2].insert(s.begin(),s.end());
+ }
+ neighborsIdx=DataArrayInt::New(); neighborsIdx->alloc(nbOfNodes+1,1); neighborsIdx->setIJ(0,0,0);
+ {
+ int *neighIdx(neighborsIdx->getPointer());
+ for(std::vector< std::set<int> >::const_iterator it=st0.begin();it!=st0.end();it++,neighIdx++)
+ neighIdx[1]=neighIdx[0]+(*it).size()-1;
+ }
+ neighbors=DataArrayInt::New(); neighbors->alloc(neighborsIdx->back(),1);
+ {
+ const int *neighIdx(neighborsIdx->begin());
+ int *neigh(neighbors->getPointer()),nodeId(0);
+ for(std::vector< std::set<int> >::const_iterator it=st0.begin();it!=st0.end();it++,neighIdx++,nodeId++)
+ {
+ std::set<int> s(*it); s.erase(nodeId);
+ std::copy(s.begin(),s.end(),neigh+*neighIdx);
+ }
+ }
+}
+
/*!
* Converts specified cells to either polygons (if \a this is a 2D mesh) or
* polyhedrons (if \a this is a 3D mesh). The cells to convert are specified by an
int nbOfCells(getNumberOfCells());
if(dim==2)
{
- const int *connIndex=_nodal_connec_index->getConstPointer();
+ const int *connIndex=_nodal_connec_index->begin();
int *conn=_nodal_connec->getPointer();
for(const int *iter=cellIdsToConvertBg;iter!=cellIdsToConvertEnd;iter++)
{
DAInt neighIInit00(tmp11);
// Neighbor information of the mesh WITH the crack (some neighbors are removed):
DataArrayInt *idsTmp=0;
- bool b=m01->areCellsIncludedIn(&otherDimM1OnSameCoords,2,idsTmp);
+ m01->areCellsIncludedIn(&otherDimM1OnSameCoords,2,idsTmp);
DAInt ids(idsTmp);
// In the neighbor information remove the connection between high dimension cells and its low level constituents which are part
// of the frontier given in parameter (i.e. the cells of low dimension from the group delimiting the crack):
* Copy constructor. If 'deepCopy' is false \a this is a shallow copy of other.
* If 'deeCpy' is true all arrays (coordinates and connectivities) are deeply copied.
*/
-MEDCouplingUMesh::MEDCouplingUMesh(const MEDCouplingUMesh& other, bool deepCopy):MEDCouplingPointSet(other,deepCopy),_mesh_dim(other._mesh_dim),
+MEDCouplingUMesh::MEDCouplingUMesh(const MEDCouplingUMesh& other, bool deepCpy):MEDCouplingPointSet(other,deepCpy),_mesh_dim(other._mesh_dim),
_nodal_connec(0),_nodal_connec_index(0),
_types(other._types)
{
if(other._nodal_connec)
- _nodal_connec=other._nodal_connec->performCopyOrIncrRef(deepCopy);
+ _nodal_connec=other._nodal_connec->performCopyOrIncrRef(deepCpy);
if(other._nodal_connec_index)
- _nodal_connec_index=other._nodal_connec_index->performCopyOrIncrRef(deepCopy);
+ _nodal_connec_index=other._nodal_connec_index->performCopyOrIncrRef(deepCpy);
}
MEDCouplingUMesh::~MEDCouplingUMesh()
std::vector<std::vector<int> > res;
buildSubCellsFromCut(cut3DSurf,desc2->begin(),descIndx2->begin(),mDesc1->getCoords()->begin(),eps,res);
std::size_t sz(res.size());
- if(res.size()==mDesc1->getNumberOfCells() && sameNbNodes)
+ if((int)res.size()==mDesc1->getNumberOfCells() && sameNbNodes)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::clipSingle3DCellByPlane : cell is not clipped !");
for(std::size_t i=0;i<sz;i++)
{
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::distanceToPoints works only for spaceDim=meshDim+1 !");
if(meshDim!=2 && meshDim!=1)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::distanceToPoints : only mesh dimension 2 and 1 are implemented !");
- if(pts->getNumberOfComponents()!=spaceDim)
+ if((int)pts->getNumberOfComponents()!=spaceDim)
{
std::ostringstream oss; oss << "MEDCouplingUMesh::distanceToPoints : input pts DataArrayDouble has " << pts->getNumberOfComponents() << " components whereas it should be equal to " << spaceDim << " (mesh spaceDimension) !";
throw INTERP_KERNEL::Exception(oss.str());
updateTime();
}
+/*!
+ * This method invert orientation of all cells in \a this.
+ * After calling this method the absolute value of measure of cells in \a this are the same than before calling.
+ * This method only operates on the connectivity so coordinates are not touched at all.
+ */
+void MEDCouplingUMesh::invertOrientationOfAllCells()
+{
+ checkConnectivityFullyDefined();
+ std::set<INTERP_KERNEL::NormalizedCellType> gts(getAllGeoTypes());
+ int *conn(_nodal_connec->getPointer());
+ const int *conni(_nodal_connec_index->begin());
+ for(std::set<INTERP_KERNEL::NormalizedCellType>::const_iterator gt=gts.begin();gt!=gts.end();gt++)
+ {
+ INTERP_KERNEL::AutoCppPtr<INTERP_KERNEL::OrientationInverter> oi(INTERP_KERNEL::OrientationInverter::BuildInstanceFrom(*gt));
+ MCAuto<DataArrayInt> cwt(giveCellsWithType(*gt));
+ for(const int *it=cwt->begin();it!=cwt->end();it++)
+ oi->operate(conn+conni[*it]+1,conn+conni[*it+1]);
+ }
+ updateTime();
+}
+
/*!
* Finds and fixes incorrectly oriented linear extruded volumes (INTERP_KERNEL::NORM_HEXA8,
* INTERP_KERNEL::NORM_PENTA6, INTERP_KERNEL::NORM_HEXGP12 etc) to respect the MED convention
for(int i=0;i<nbOfCells;i++,nodalI++,retPtr+=4)
{
double matrix[16]={0,0,0,1,0,0,0,1,0,0,0,1,1,1,1,0},matrix2[16];
- if(nodalI[1]-nodalI[0]>=3)
+ if(nodalI[1]-nodalI[0]>=4)
{
+ double aa[3]={coor[nodal[nodalI[0]+1+1]*3+0]-coor[nodal[nodalI[0]+1+0]*3+0],
+ coor[nodal[nodalI[0]+1+1]*3+1]-coor[nodal[nodalI[0]+1+0]*3+1],
+ coor[nodal[nodalI[0]+1+1]*3+2]-coor[nodal[nodalI[0]+1+0]*3+2]}
+ ,bb[3]={coor[nodal[nodalI[0]+1+2]*3+0]-coor[nodal[nodalI[0]+1+0]*3+0],
+ coor[nodal[nodalI[0]+1+2]*3+1]-coor[nodal[nodalI[0]+1+0]*3+1],
+ coor[nodal[nodalI[0]+1+2]*3+2]-coor[nodal[nodalI[0]+1+0]*3+2]};
+ double cc[3]={aa[1]*bb[2]-aa[2]*bb[1],aa[2]*bb[0]-aa[0]*bb[2],aa[0]*bb[1]-aa[1]*bb[0]};
for(int j=0;j<3;j++)
{
int nodeId(nodal[nodalI[0]+1+j]);
throw INTERP_KERNEL::Exception(oss.str());
}
}
+ if(sqrt(cc[0]*cc[0]+cc[1]*cc[1]+cc[2]*cc[2])>1e-7)
+ {
+ INTERP_KERNEL::inverseMatrix(matrix,4,matrix2);
+ retPtr[0]=matrix2[3]; retPtr[1]=matrix2[7]; retPtr[2]=matrix2[11]; retPtr[3]=matrix2[15];
+ }
+ else
+ {
+ if(nodalI[1]-nodalI[0]==4)
+ {
+ std::ostringstream oss; oss << "MEDCouplingUMesh::computePlaneEquationOf3DFaces : cell" << i << " : Presence of The 3 colinear points !";
+ throw INTERP_KERNEL::Exception(oss.str());
+ }
+ //
+ double dd[3]={0.,0.,0.};
+ for(int offset=nodalI[0]+1;offset<nodalI[1];offset++)
+ std::transform(coor+3*nodal[offset],coor+3*(nodal[offset]+1),dd,dd,std::plus<double>());
+ int nbOfNodesInCell(nodalI[1]-nodalI[0]-1);
+ std::transform(dd,dd+3,dd,std::bind2nd(std::multiplies<double>(),1./(double)nbOfNodesInCell));
+ std::copy(dd,dd+3,matrix+4*2);
+ INTERP_KERNEL::inverseMatrix(matrix,4,matrix2);
+ retPtr[0]=matrix2[3]; retPtr[1]=matrix2[7]; retPtr[2]=matrix2[11]; retPtr[3]=matrix2[15];
+ }
}
else
{
std::ostringstream oss; oss << "MEDCouplingUMesh::computePlaneEquationOf3DFaces : invalid 2D cell #" << i << " ! Must be constitued by more than 3 nodes !";
throw INTERP_KERNEL::Exception(oss.str());
}
- INTERP_KERNEL::inverseMatrix(matrix,4,matrix2);
- retPtr[0]=matrix2[3]; retPtr[1]=matrix2[7]; retPtr[2]=matrix2[11]; retPtr[3]=matrix2[15];
}
return ret.retn();
}
return MergeVorCells2D(p,eps,true);
}
+ /*!
+ * suppress additional sub points on edges
+ */
+ MCAuto<MEDCouplingUMesh> SimplifyPolygon(const MEDCouplingUMesh *m, double eps)
+ {
+ if(m->getNumberOfCells()!=1)
+ throw INTERP_KERNEL::Exception("SimplifyPolygon : internal error !");
+ const int *conn(m->getNodalConnectivity()->begin()),*conni(m->getNodalConnectivityIndex()->begin());
+ int nbPtsInPolygon(conni[1]-conni[0]-1);
+ const double *coo(m->getCoords()->begin());
+ std::vector<int> resConn;
+ for(int i=0;i<nbPtsInPolygon;i++)
+ {
+ int prev(conn[(i+nbPtsInPolygon-1)%nbPtsInPolygon+1]),current(conn[i%nbPtsInPolygon+1]),zeNext(conn[(i+1)%nbPtsInPolygon+1]);
+ double a[3]={
+ coo[3*prev+0]-coo[3*current+0],
+ coo[3*prev+1]-coo[3*current+1],
+ coo[3*prev+2]-coo[3*current+2],
+ },b[3]={
+ coo[3*current+0]-coo[3*zeNext+0],
+ coo[3*current+1]-coo[3*zeNext+1],
+ coo[3*current+2]-coo[3*zeNext+2],
+ };
+ double c[3]={a[1]*b[2]-a[2]*b[1], a[2]*b[0]-a[0]*b[2], a[0]*b[1]-a[1]*b[0]};
+ if(sqrt(c[0]*c[0]+c[1]*c[1]+c[2]*c[2])>eps)
+ resConn.push_back(current);
+ }
+ MCAuto<MEDCouplingUMesh> ret(MEDCouplingUMesh::New("",2));
+ ret->setCoords(m->getCoords());
+ ret->allocateCells();
+ ret->insertNextCell(INTERP_KERNEL::NORM_POLYGON,resConn.size(),&resConn[0]);
+ return ret;
+ }
+
MCAuto<MEDCouplingUMesh> MergeVorCells3D(const std::vector< MCAuto<MEDCouplingUMesh> >& vcs, double eps)
{
std::size_t sz(vcs.size());
tmp2=tmp;
else
tmp2=MergeVorCells2D(tmp,eps,false);
+ tmp2=SimplifyPolygon(tmp2,eps);
const int *cPtr(tmp2->getNodalConnectivity()->begin()),*ciPtr(tmp2->getNodalConnectivityIndex()->begin());
conn.insert(conn.end(),cPtr+1,cPtr+ciPtr[1]);
}
newCoords=a->getCoords()->selectByTupleId(tmp->begin(),tmp->end());
}
const double *cPtr(newCoords->begin());
- for(int i=0;i<newCoords->getNumberOfTuples();i++,cPtr+=2)
+ for(int j=0;j<newCoords->getNumberOfTuples();j++,cPtr+=2)
{
std::set<int> zeCandidates;
{
vorTess->getCellsContainingPoint(pt,eps,polygsToIterOn);
if(polygsToIterOn.size()<1)
throw INTERP_KERNEL::Exception("Voronoize3D : presence of a point outside the given cell !");
+ std::set<int> elemsToDo(polygsToIterOn.begin(),polygsToIterOn.end()),elemsDone;
+ std::size_t ii(0);
std::vector< MCAuto<MEDCouplingUMesh> > newVorCells;
- for(int poly=0;poly<vorTess->getNumberOfCells();poly++)
+ MCAuto<DataArrayInt> d(DataArrayInt::New()),dI(DataArrayInt::New()),rd(DataArrayInt::New()),rdI(DataArrayInt::New());
+ MCAuto<MEDCouplingUMesh> faces(vorTess->buildDescendingConnectivity(d,dI,rd,rdI));
+ //
+ while(!elemsToDo.empty())
{
+ int poly(*elemsToDo.begin()); elemsToDo.erase(elemsToDo.begin()); elemsDone.insert(poly);
const double *seed(pts+3*poly);
MCAuto<MEDCouplingUMesh> tile(l0[poly]);
tile->zipCoords();
newVorCell->zipCoords();
MCAuto<MEDCouplingUMesh> modifiedCell(cells->buildPartOfMySelfSlice(0,1,1,true));
modifiedCell->zipCoords();
+ l0[poly]=modifiedCell;
+ if(std::find(polygsToIterOn.begin(),polygsToIterOn.end(),poly)!=polygsToIterOn.end())// we iterate on a polyhedron containg the point to add pt -> add cells sharing faces with just computed newVorCell
+ {
+ MCAuto<MEDCouplingUMesh> faces2;
+ {
+ MCAuto<DataArrayInt> d2(DataArrayInt::New()),d2I(DataArrayInt::New()),rd2(DataArrayInt::New()),rd2I(DataArrayInt::New());
+ faces2=newVorCell->buildDescendingConnectivity(d2,d2I,rd2,rd2I);
+ }
+ MCAuto<MEDCouplingUMesh> faces3(faces2->buildPartOfMySelfSlice(1,faces2->getNumberOfCells(),1,true));// suppress internal face
+ MCAuto<MEDCouplingUMesh> facesOfCurSplitPol(faces->buildPartOfMySelf(d->begin()+dI->getIJ(poly,0),d->begin()+dI->getIJ(poly+1,0),true));
+ // intersection between the out faces of newVorCell and the neighbor faces of poly polyhedron -> candidates
+ MEDCouplingNormalizedUnstructuredMesh<3,2> source_mesh_wrapper(facesOfCurSplitPol);
+ MEDCouplingNormalizedUnstructuredMesh<3,2> target_mesh_wrapper(faces3);
+ INTERP_KERNEL::Interpolation3DSurf interpolation;
+ interpolation.setMinDotBtwPlane3DSurfIntersect(eps2);
+ interpolation.setMaxDistance3DSurfIntersect(eps);
+ interpolation.setPrecision(1e-12);
+ std::vector<std::map<int,double> > matrix;
+ interpolation.interpolateMeshes(source_mesh_wrapper,target_mesh_wrapper,matrix,"P0P0");
+ std::set<int> zeCandidates;
+ for(std::vector<std::map<int,double> >::const_iterator it2=matrix.begin();it2!=matrix.end();it2++)
+ for(std::map<int,double>::const_iterator it3=(*it2).begin();it3!=(*it2).end();it3++)
+ {
+ int faceIdInVorTess(d->getIJ(dI->getIJ(poly,0)+(*it3).first,0));
+ for(const int *it4=rd->begin()+rdI->getIJ(faceIdInVorTess,0);it4!=rd->begin()+rdI->getIJ(faceIdInVorTess+1,0);it4++)
+ {
+ if(*it4!=poly)
+ zeCandidates.insert(*it4);
+ }
+ }
+ std::set<int> tmp2,newElementsToDo;
+ std::set_difference(zeCandidates.begin(),zeCandidates.end(),elemsDone.begin(),elemsDone.end(),std::inserter(tmp2,tmp2.begin()));
+ std::set_union(elemsToDo.begin(),elemsToDo.end(),tmp2.begin(),tmp2.end(),std::inserter(newElementsToDo,newElementsToDo.begin()));
+ elemsToDo=newElementsToDo;
+ }
+ //
newVorCells.push_back(newVorCell);
- ii++;
+ l0[poly]=modifiedCell;
}
l0.push_back(MergeVorCells3D(newVorCells,eps));
}
from math import pi,e,sqrt,cos,sin
from datetime import datetime
from MEDCouplingDataForTest import MEDCouplingDataForTest
-import rlcompleter,readline # this line has to be here, to ensure a usability of MEDCoupling/MEDLoader. B4 removing it please notify to anthony.geay@cea.fr
+import rlcompleter,readline # this line has to be here, to ensure a usability of MEDCoupling/MEDLoader. B4 removing it please notify to anthony.geay@edf.fr
class MEDCouplingBasicsTest5(unittest.TestCase):
def testSwig2FieldDoubleBuildSubPartRange1(self):
m=MEDCouplingDataForTest.build2DTargetMesh_1()
f=MEDCouplingFieldDouble(ON_CELLS)
f.setMesh(m)
- arr=DataArrayDouble(5,2) ; arr[:,0]=range(7,12) ; arr[:,1]=100+arr[:,0]
+ arr = DataArrayDouble(5, 2) ; arr[:, 0] = list(range(7, 12)) ; arr[:, 1] = 100 + arr[:, 0]
f.setArray(arr)
f.checkConsistencyLight()
ff=f[1:-1:2]
#ON_NODES
f=MEDCouplingFieldDouble(ON_NODES)
f.setMesh(m)
- arr=DataArrayDouble(9,2) ; arr[:,0]=range(7,16) ; arr[:,1]=100+arr[:,0]
+ arr = DataArrayDouble(9, 2) ; arr[:, 0] = list(range(7, 16)) ; arr[:, 1] = 100 + arr[:, 0]
f.setArray(arr)
f.checkConsistencyLight()
ff=f[1:-1:2]
#ON_GAUSS_NE
f=MEDCouplingFieldDouble(ON_GAUSS_NE)
f.setMesh(m)
- arr=DataArrayDouble(18,2) ; arr[:,0]=range(7,25) ; arr[:,1]=100+arr[:,0]
+ arr = DataArrayDouble(18, 2) ; arr[:, 0] = list(range(7, 25)) ; arr[:, 1] = 100 + arr[:, 0]
f.setArray(arr)
f.checkConsistencyLight()
ff=f[1:-1:2]
f.setGaussLocalizationOnCells([3],[0,0,1,0,1,1,1,0],[1.1,1.1,2.2,2.2,3.,3.],[0.2,0.4,0.4]);
f.setGaussLocalizationOnCells([1],[0,0,1,0,1,0],[1.1,1.1,2.2,2.2,3.,3.,4.,4.],[0.1,0.1,0.4,0.4]);
f.setGaussLocalizationOnCells([2],[0,0,1,0,1,0],[1.1,1.1,2.2,2.2,3.,3.,4.,4.,5.,5.],[0.1,0.1,0.4,0.3,0.1]);
- arr=DataArrayDouble(16,2) ; arr[:,0]=range(7,23) ; arr[:,1]=100+arr[:,0]
+ arr = DataArrayDouble(16, 2) ; arr[:, 0] = list(range(7, 23)) ; arr[:, 1] = 100 + arr[:, 0]
f.setArray(arr)
f.checkConsistencyLight()
ff=f[1:-1:2]
time_deb = datetime.now()
a1=DataArrayDouble(len(d))
b1=DataArrayInt(len(d))
- m1s=[m1[i] for i in xrange(m1.getNumberOfCells())]
+ m1s = [m1[i] for i in range(m1.getNumberOfCells())]
for j,pt in enumerate(d):
eter=1e308
fter=-1
m=MEDCouplingUMesh("mesh",2)
m.setCoords(coo)
m.allocateCells()
- for i in xrange(24):
+ for i in range(24):
m.insertNextCell(NORM_QUAD4,conn[4*i:4*i+4])
pass
m.checkConsistency()
d[:,1]*=pi/180. # angle in radian
d=d.fromPolarToCart()
d+=zeBary
- m=MEDCouplingUMesh("quad8",2) ; m.allocateCells() ; m.insertNextCell(NORM_QUAD8,range(8)) ; m.setCoords(d)
+ m = MEDCouplingUMesh("quad8", 2) ; m.allocateCells() ; m.insertNextCell(NORM_QUAD8, list(range(8))) ; m.setCoords(d)
self.assertTrue(m.computeCellCenterOfMass().isEqual(DataArrayDouble(zeBary,1,2),1e-13))
self.assertAlmostEqual(float(m.getMeasureField(False).getArray()),pi*zeRadius*zeRadius,12)
tri32D=m.buildDescendingConnectivity()[0][0] ; tri32D.zipCoords()
d[:,1]*=pi/180. # angle in radian
d=d.fromPolarToCart()
d+=zeBary
- m=MEDCouplingUMesh("tri6",2) ; m.allocateCells() ; m.insertNextCell(NORM_TRI6,range(6)) ; m.setCoords(d)
+ m = MEDCouplingUMesh("tri6", 2) ; m.allocateCells() ; m.insertNextCell(NORM_TRI6, list(range(6))) ; m.setCoords(d)
self.assertTrue(m.computeCellCenterOfMass().isEqual(DataArrayDouble(zeBary,1,2),1e-13))
self.assertAlmostEqual(float(m.getMeasureField(False).getArray()),pi*zeRadius*zeRadius,12)
# spaceDim=3 TRI6 becomes TRI3 ... for the moment
d[:,1]*=pi/180. # angle in radian
d=d.fromPolarToCart()
d+=zeBary
- m=MEDCouplingUMesh("qpolyg",2) ; m.allocateCells() ; m.insertNextCell(NORM_QPOLYG,range(10)) ; m.setCoords(d)
+ m = MEDCouplingUMesh("qpolyg", 2) ; m.allocateCells() ; m.insertNextCell(NORM_QPOLYG, list(range(10))) ; m.setCoords(d)
self.assertTrue(m.computeCellCenterOfMass().isEqual(DataArrayDouble(zeBary,1,2),1e-13))
self.assertAlmostEqual(float(m.getMeasureField(False).getArray()),pi*zeRadius*zeRadius,12)
# spaceDim=3 QPOLYG becomes POLYG ... for the moment
s=slice(18,1,-2)
self.assertEqual(DataArray.GetNumberOfItemGivenBESRelative(s),9)
self.assertRaises(InterpKernelException,DataArray.GetNumberOfItemGivenBES,s)
- self.assertEqual(sum([DataArray.GetNumberOfItemGivenBESRelative(DataArray.GetSlice(s,i,4)) for i in xrange(4)]),DataArray.GetNumberOfItemGivenBESRelative(s))
+ self.assertEqual(sum([DataArray.GetNumberOfItemGivenBESRelative(DataArray.GetSlice(s, i, 4)) for i in range(4)]), DataArray.GetNumberOfItemGivenBESRelative(s))
self.assertEqual(DataArray.GetSlice(s,0,4),slice(18,14,-2))
self.assertEqual(DataArray.GetSlice(s,1,4),slice(14,10,-2))
self.assertEqual(DataArray.GetSlice(s,2,4),slice(10,6,-2))
#
maxNbCSN=nbOfCellsSharingNodes.getMaxValue()[0]
arr3=DataArrayDouble(f.getMesh().getNumberOfNodes(),f.getArray().getNumberOfComponents()) ; arr3[:]=0.
- for i in xrange(1,maxNbCSN+1):
+ for i in range(1, maxNbCSN + 1):
ids=nbOfCellsSharingNodes.findIdsEqual(i)
if len(ids)==0:
continue
m=MEDCoupling1SGTUMesh("m",NORM_QUAD4)
mem_m=m.getHeapMemorySize()
m.allocateCells(5)
- self.assertIn(m.getHeapMemorySize()-mem_m,xrange(5*4*4,5*4*4+32))
+ self.assertIn(m.getHeapMemorySize() - mem_m, list(range(5 * 4 * 4, 5 * 4 * 4 + 32)))
self.assertEqual(m.getNodalConnectivity().getNbOfElemAllocated(),20)
m.setCoords(um.getCoords())
m.insertNextCell([1,0,6,7])
self.assertRaises(InterpKernelException,m.buildUnstructured().splitProfilePerType,invalidPfl)
##
pfl1=DataArrayInt([1,2,3])
-- a=m.checkTypeConsistencyAndContig([NORM_QUAD4,3,0],[pfl1])
++ a=m.getCellsContainingPointcheckTypeConsistencyAndContig([NORM_QUAD4,3,0],[pfl1])
b=m.buildUnstructured().checkTypeConsistencyAndContig([NORM_QUAD4,3,0],[pfl1])
self.assertTrue(a.isEqual(b) and pfl1.getHiddenCppPointer(),a.getHiddenCppPointer())
#
valuesToTest=f.getValueOnMulti(targetPointCoordsXY);
self.assertEqual(196,valuesToTest.getNumberOfTuples());
self.assertEqual(1,valuesToTest.getNumberOfComponents());
- for i in xrange(40):
+ for i in range(40):
self.assertAlmostEqual(targetFieldValsExpected[i],valuesToTest.getIJ(i,0),10)
pass
fd=f.getDiscretization()
#
trs=[[0.,0.,-1.],[0.,0.,1.],[1.,0.,0.],[0.,-1.,0.],[-1.,0.,0.],[0.,1.,0.]]
for i,t in enumerate(trs):
- for j in xrange(64):
+ for j in range(64):
j2=(j//16) ; j1=((j%16)//4) ; j0=(j%4)
m11=m1.deepCopy()
m11.rotate([0.,0.,0.],[0.,0.,1.],float(j0)*pi/2)
m=MEDCouplingUMesh("mesh",2) ; m.setCoords(coo)
m.allocateCells()
# the cell description is exactly those described in the description of TRI7 in MED file 3.0.7 documentation
- m.insertNextCell(NORM_TRI7,range(7))
+ m.insertNextCell(NORM_TRI7, list(range(7)))
refCoords=[0.,0.,1.,0.,0.,1.,0.5,0.,0.5,0.5,0.,0.5,0.3333333333333333,0.3333333333333333]
gaussCoords=[0.3333333333333333,0.3333333333333333,0.470142064105115,0.470142064105115,0.05971587178977,0.470142064105115,0.470142064105115,0.05971587178977,0.101286507323456,0.101286507323456,0.797426985353088,0.101286507323456,0.101286507323456,0.797426985353088]
weights=[0.062969590272413,0.062969590272413,0.062969590272413,0.066197076394253,0.066197076394253,0.066197076394253,0.1125]
def testSwigBugOnUnpackingTuplesInDataArray1(self):
inp=DataArrayDouble([(1,2,3),(4,5,6),(7,8,9),(10,11,12)])
it=inp.__iter__()
- r=it.next()
+ r = next(it)
self.assertRaises(StopIteration,r.__getitem__,4)
self.assertEqual(len(r),3)
a,b,c=r
- r=it.next()
+ r = next(it)
self.assertEqual(len(r),3)
d,e,f=r
- r=it.next()
+ r = next(it)
self.assertEqual(len(r),3)
g,h,i=r
- r=it.next()
+ r = next(it)
self.assertEqual(len(r),3)
j,k,l=r
self.assertTrue(inp.isEqual(DataArrayDouble([a,b,c,d,e,f,g,h,i,j,k,l],4,3),1e-12))
########
inp=DataArrayInt([(1,2,3),(4,5,6),(7,8,9),(10,11,12)])
it=inp.__iter__()
- r=it.next()
+ r = next(it)
self.assertRaises(StopIteration,r.__getitem__,4)
self.assertEqual(len(r),3)
a,b,c=r
- r=it.next()
+ r = next(it)
self.assertEqual(len(r),3)
d,e,f=r
- r=it.next()
+ r = next(it)
self.assertEqual(len(r),3)
g,h,i=r
- r=it.next()
+ r = next(it)
self.assertEqual(len(r),3)
j,k,l=r
self.assertTrue(inp.isEqual(DataArrayInt([a,b,c,d,e,f,g,h,i,j,k,l],4,3)))
self.assertTrue(isinstance(g0[0],MEDCouplingCartesianAMRPatchGF))
g1=amr.retrieveGridsAt(1)
self.assertEqual(5,len(g1))
- for i in xrange(5):
+ for i in range(5):
self.assertTrue(isinstance(g1[i],MEDCouplingCartesianAMRPatch))
pass
pass
NORM_SEG2,11,12,NORM_SEG2,12,13,
NORM_SEG2,14,15])
cI = DataArrayInt([0,3,7,10,14,18,21,24,27,30])
- coords2 = DataArrayDouble([float(i) for i in range(32)], 16,2)
+ coords2 = DataArrayDouble([float(i) for i in range(32)], 16, 2)
m2.setCoords(coords2);
m2.setConnectivity(c, cI);
m2.checkConsistency(1.0e-8);
def testSwig2DAIGetIdsStrictlyNegative1(self):
d=DataArrayInt([4,-5,-1,0,3,99,-7])
- self.assertTrue(d.findIdsStricltyNegative().isEqual(DataArrayInt([1,2,6])))
+ self.assertTrue(d.findIdsStrictlyNegative().isEqual(DataArrayInt([1,2,6])))
pass
def testSwig2DAIReplaceOneValByInThis1(self):
li=[]
liExp3D=[(0,0,0),(1,0,0),(2,0,0),(3,0,0),(0,1,0),(1,1,0),(2,1,0),(3,1,0),(0,2,0),(1,2,0),(2,2,0),(3,2,0),(0,0,1),(1,0,1),(2,0,1),(3,0,1),(0,1,1),(1,1,1),(2,1,1),(3,1,1),(0,2,1),(1,2,1),(2,2,1),(3,2,1)]
self.assertEqual(24,m.getNumberOfCells())
- for i in xrange(m.getNumberOfCells()):
+ for i in range(m.getNumberOfCells()):
li.append(m.getLocationFromCellId(i))
pass
self.assertEqual(liExp3D,li)
li=[]
liExp2D=[(0,0),(1,0),(2,0),(3,0),(0,1),(1,1),(2,1),(3,1),(0,2),(1,2),(2,2),(3,2)]
self.assertEqual(12,m.getNumberOfCells())
- for i in xrange(m.getNumberOfCells()):
+ for i in range(m.getNumberOfCells()):
li.append(m.getLocationFromCellId(i))
pass
self.assertEqual(liExp2D,li)
arrX=DataArrayDouble(5) ; arrX.iota()
m=MEDCouplingCMesh() ; m.setCoords(arrX)
self.assertEqual(4,m.getNumberOfCells())
- for i in xrange(m.getNumberOfCells()):
+ for i in range(m.getNumberOfCells()):
self.assertEqual((i,),m.getLocationFromCellId(i))
pass
self.assertRaises(InterpKernelException,m.getLocationFromCellId,4)
li=[]
liExp3D=[(0,0,0),(1,0,0),(2,0,0),(3,0,0),(4,0,0),(0,1,0),(1,1,0),(2,1,0),(3,1,0),(4,1,0),(0,2,0),(1,2,0),(2,2,0),(3,2,0),(4,2,0),(0,3,0),(1,3,0),(2,3,0),(3,3,0),(4,3,0),(0,0,1),(1,0,1),(2,0,1),(3,0,1),(4,0,1),(0,1,1),(1,1,1),(2,1,1),(3,1,1),(4,1,1),(0,2,1),(1,2,1),(2,2,1),(3,2,1),(4,2,1),(0,3,1),(1,3,1),(2,3,1),(3,3,1),(4,3,1),(0,0,2),(1,0,2),(2,0,2),(3,0,2),(4,0,2),(0,1,2),(1,1,2),(2,1,2),(3,1,2),(4,1,2),(0,2,2),(1,2,2),(2,2,2),(3,2,2),(4,2,2),(0,3,2),(1,3,2),(2,3,2),(3,3,2),(4,3,2)]
self.assertEqual(60,m.getNumberOfNodes())
- for i in xrange(m.getNumberOfNodes()):
+ for i in range(m.getNumberOfNodes()):
li.append(m.getLocationFromNodeId(i))
pass
self.assertEqual(liExp3D,li)
li=[]
liExp2D=[(0,0),(1,0),(2,0),(3,0),(4,0),(0,1),(1,1),(2,1),(3,1),(4,1),(0,2),(1,2),(2,2),(3,2),(4,2),(0,3),(1,3),(2,3),(3,3),(4,3)]
self.assertEqual(20,m.getNumberOfNodes())
- for i in xrange(m.getNumberOfNodes()):
+ for i in range(m.getNumberOfNodes()):
li.append(m.getLocationFromNodeId(i))
pass
self.assertEqual(liExp2D,li)
arrX=DataArrayDouble(5) ; arrX.iota()
m=MEDCouplingCMesh() ; m.setCoords(arrX)
self.assertEqual(5,m.getNumberOfNodes())
- for i in xrange(m.getNumberOfNodes()):
+ for i in range(m.getNumberOfNodes()):
self.assertEqual((i,),m.getLocationFromNodeId(i))
pass
self.assertRaises(InterpKernelException,m.getLocationFromCellId,5)
st0=d.repr() ; st1=str(d) ; st2=d.reprNotTooLong()
self.assertNotEqual(st0,st1) # 1001 tuples ( > 1000) -> str(d)==d.reprNotTooLong()
self.assertEqual(st1,st2)
- self.assertIn(len(st2),xrange(0,1000)) # no more than 1000 characters
+ self.assertIn(len(st2), list(range(0, 1000))) # no more than 1000 characters
## Now for DataArrayInt
d=DataArrayInt(2000) ; d.iota() ; d.rearrange(2)
st0=d.repr() ; st1=str(d) ; st2=d.reprNotTooLong()
st0=d.repr() ; st1=str(d) ; st2=d.reprNotTooLong()
self.assertNotEqual(st0,st1) # 1001 tuples ( > 1000) -> str(d)==d.reprNotTooLong()
self.assertEqual(st1,st2)
- self.assertIn(len(st2),xrange(0,1000)) # no more than 1000 characters
+ self.assertIn(len(st2), list(range(0, 1000))) # no more than 1000 characters
pass
def testExtrudedMeshWithoutZipCoords1(self):
coo=DataArrayDouble([(0,2),(2,0),(6,4),(4,9)])
m=MEDCoupling1SGTUMesh("mesh",NORM_QUAD4) ; m.setCoords(coo)
exp3=sqrt(85.)
- for delta in xrange(4):
- c=[(elt+delta)%4 for elt in xrange(4)]
+ for delta in range(4):
+ c = [(elt + delta) % 4 for elt in range(4)]
m.setNodalConnectivity(DataArrayInt(c))
self.assertAlmostEqual(m.computeDiameterField().getArray()[0],exp3,12)
m2=m.buildUnstructured() ; m2.convertLinearCellsToQuadratic(0)
# QUAD4 - spacedim = 3
coo=DataArrayDouble([(0.26570992384234871,2.0405889913271817,-0.079134238105786903),(2.3739976619218064,0.15779148692781009,0.021842842914139737),(6.1207841448393197,4.3755532938679655,0.43666375769970678),(3.8363255342943359,9.2521096041694229,0.41551170895942313)])
m=MEDCoupling1SGTUMesh("mesh",NORM_QUAD4) ; m.setCoords(coo)
- for delta in xrange(4):
- c=[(elt+delta)%4 for elt in xrange(4)]
+ for delta in range(4):
+ c = [(elt + delta) % 4 for elt in range(4)]
m.setNodalConnectivity(DataArrayInt(c))
self.assertAlmostEqual(m.computeDiameterField().getArray()[0],exp3,12)
m2=m.buildUnstructured() ; m2.convertLinearCellsToQuadratic(0)
m=MEDCoupling1SGTUMesh("mesh",NORM_PENTA6) ; m.setCoords(coo)
exp4=2.5041256256889888
self.assertAlmostEqual(exp4,coo.buildEuclidianDistanceDenseMatrix().getMaxValue()[0],12)# <- the definition of diameter
- for delta in xrange(3):
- c=[(elt+delta)%3 for elt in xrange(3)]
+ for delta in range(3):
+ c = [(elt + delta) % 3 for elt in range(3)]
c+=[elt+3 for elt in c]
m.setNodalConnectivity(DataArrayInt(c))
self.assertAlmostEqual(m.computeDiameterField().getArray()[0],exp4,12)
m=MEDCoupling1SGTUMesh("mesh",NORM_HEXA8) ; m.setCoords(coo)
exp5=2.5366409441884215
self.assertAlmostEqual(exp5,coo.buildEuclidianDistanceDenseMatrix().getMaxValue()[0],12)# <- the definition of diameter
- for delta in xrange(4):
- c=[(elt+delta)%4 for elt in xrange(4)]
+ for delta in range(4):
+ c = [(elt + delta) % 4 for elt in range(4)]
c+=[elt+4 for elt in c]
m.setNodalConnectivity(DataArrayInt(c))
self.assertAlmostEqual(m.computeDiameterField().getArray()[0],exp5,12)
m=MEDCoupling1SGTUMesh("mesh",NORM_PYRA5) ; m.setCoords(coo)
exp6=2.1558368027391386
self.assertAlmostEqual(exp6,coo.buildEuclidianDistanceDenseMatrix().getMaxValue()[0],12)# <- the definition of diameter
- for delta in xrange(4):
- c=[(elt+delta)%4 for elt in xrange(4)]
+ for delta in range(4):
+ c = [(elt + delta) % 4 for elt in range(4)]
c+=[4]
m.setNodalConnectivity(DataArrayInt(c))
self.assertAlmostEqual(m.computeDiameterField().getArray()[0],exp6,12)
m=MEDCoupling1SGTUMesh("mesh",NORM_PYRA5) ; m.setCoords(coo)
exp7=1.4413563787228953
self.assertAlmostEqual(exp7,coo.buildEuclidianDistanceDenseMatrix().getMaxValue()[0],12)# <- the definition of diameter
- for delta in xrange(4):
- c=[(elt+delta)%4 for elt in xrange(4)]
+ for delta in range(4):
+ c = [(elt + delta) % 4 for elt in range(4)]
c+=[4]
m.setNodalConnectivity(DataArrayInt(c))
self.assertAlmostEqual(m.computeDiameterField().getArray()[0],exp7,12)
exp8=1.7131322579364157
self.assertAlmostEqual(exp8,coo.buildEuclidianDistanceDenseMatrix().getMaxValue()[0],12)# <- the definition of diameter
for c in [[0,1,2,3],[0,3,2,1],[0,1,3,2],[0,2,3,1],[0,3,1,2],[0,2,1,3]]:
- for i in xrange(4):
+ for i in range(4):
m.setNodalConnectivity(DataArrayInt([(elt+i)%4 for elt in c]))
self.assertAlmostEqual(m.computeDiameterField().getArray()[0],exp8,12)
m2=m.buildUnstructured() ; m2.convertLinearCellsToQuadratic(0)
self.assertTrue(f3.getArray().isEqual(DataArrayDouble([0,1,2,3]),1e-12))
pass
+ def testVoronoi3D_5(self):
+ """ Cell 0 of Barreau_Elga_V11.rmed and sslv07b.rmed. HEXA8 cut regularly into 8 parts"""
+ coo=DataArrayDouble([(0.024,0.024,1.2),(0.024,0.048,1.2),(0.048,0.024,1.2),(0.048,0.048,1.2),(0.024,0.024,1.6),(0.024,0.048,1.6),(0.048,0.024,1.6),(0.048,0.048,1.6)])
+ m=MEDCouplingUMesh("",3) ; m.setCoords(coo) ; m.allocateCells()
+ m.insertNextCell(NORM_HEXA8,[0,2,6,4,1,3,7,5])
+ f=MEDCouplingFieldDouble(ON_GAUSS_PT) ; f.setMesh(m)
+ f.setGaussLocalizationOnType(NORM_HEXA8,[-1.0, -1.0, -1.0, -1.0, 1.0, -1.0, 1.0, 1.0, -1.0, 1.0, -1.0, -1.0, -1.0, -1.0, 1.0, -1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, -1.0, 1.0],[-0.577350269189626, -0.577350269189626, -0.577350269189626, -0.577350269189626, -0.577350269189626, 0.577350269189626, -0.577350269189626, 0.577350269189626, -0.577350269189626, -0.577350269189626, 0.577350269189626, 0.577350269189626, 0.577350269189626, -0.577350269189626, -0.577350269189626, 0.577350269189626, -0.577350269189626, 0.577350269189626, 0.577350269189626, 0.577350269189626, -0.577350269189626, 0.577350269189626, 0.577350269189626, 0.577350269189626],[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0])
+ arr=DataArrayDouble(8) ; arr.iota() ; f.setArray(arr)
+ f.checkConsistencyLight()
+ #
+ vol=f.getMesh().getMeasureField(False).getIJ(0,0)
+ f2=f.voronoize(1e-12)
+ f2.checkConsistencyLight()
+ self.assertEqual(f2.getNumberOfTuples(),8)
+ volRef=vol/8
+ self.assertTrue(f2.getMesh().getMeasureField(False).getArray().isUniform(volRef,1e-12))
+ pass
+
+ def testVoronoi3D_6(self):
+ """ Cell 0 of brokenshire.med (and pace.med). TETRA10 split into 4 parts"""
+ coo=DataArrayDouble([(50.,-50.,200.0),(50.0,-30.,200.0),(30.,-50.,200.0),(50.,-50.,180.0),(50.,-40.,200.0),(40.,-50.,200.0),(50.,-50.,190.0),(40.,-40.,200.0),(50.,-40.,190.0),(40.,-50.,190.0)])
+ m=MEDCouplingUMesh("",3) ; m.setCoords(coo) ; m.allocateCells()
+ m.insertNextCell(NORM_TETRA10,[2,0,1,3,5,4,7,9,6,8])
+ f=MEDCouplingFieldDouble(ON_GAUSS_PT) ; f.setMesh(m)
+ f.setGaussLocalizationOnType(NORM_TETRA10,[0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0.5, 0, 0, 0, 0.5, 0, 0.5, 0.5, 0.5, 0.5, 0, 0.5, 0, 0, 0.5, 0, 0.5],[0.1381966011250105, 0.1381966011250105, 0.1381966011250105, 0.1381966011250105, 0.1381966011250105, 0.5854101966249685, 0.1381966011250105, 0.5854101966249685, 0.1381966011250105, 0.5854101966249685, 0.1381966011250105, 0.1381966011250105],[0.041666666666666664, 0.041666666666666664, 0.041666666666666664, 0.041666666666666664])
+ arr=DataArrayDouble(4) ; arr.iota() ; f.setArray(arr)
+ f.checkConsistencyLight()
+ f2=f.voronoize(1e-12)
+ f2.checkConsistencyLight()
+ self.assertEqual(f2.getNumberOfTuples(),4)
+ arr=f2.getMesh().getMeasureField(False).getArray()
+ self.assertTrue(f2.getMesh().getMeasureField(False).getArray().isEqual(DataArrayDouble([378.0546928833331, 318.42621348333586, 318.4262134833361, 318.4262134833278]),1e-6))
+ pass
+
+ def testVoronoi3D_7(self):
+ """ sslv07a.rmed. HEXA20 split into 27 parts """
+ coo=DataArrayDouble([(-0.5,-0.5,0.0),(-0.25,-0.5,0.0),(0.0,-0.5,0.0),(-0.5,0.0,0.0),(-0.5,-0.25,0.0),(0.0,0.0,0.0),(0.0,-0.25,0.0),(-0.25,0.0,0.0),(-0.5,-0.5,1.0),(-0.25,-0.5,1.0),(0.0,-0.5,1.0),(0.0,-0.25,1.0),(0.0,0.0,1.0),(-0.25,0.0,1.0),(-0.5,0.0,1.0),(-0.5,-0.25,1.0),(-0.5,-0.5,0.5),(0.0,-0.5,0.5),(0.0,0.0,0.5),(-0.5,0.0,0.5)])
+ m=MEDCouplingUMesh("",3) ; m.setCoords(coo) ; m.allocateCells()
+ m.insertNextCell(NORM_HEXA20,[0,3,5,2,8,14,12,10,4,7,6,1,15,13,11,9,16,19,18,17])
+ f=MEDCouplingFieldDouble(ON_GAUSS_PT) ; f.setMesh(m)
+ f.setGaussLocalizationOnType(NORM_HEXA20,
+ [-1,-1,-1,-1,1,-1,1,1,-1,1,-1,-1,-1,-1,1,-1,1,1,1,1,1,1,-1,1,-1,0,-1,0,1,-1,1,0,-1,0,-1,-1,-1,0,1,0,1,1,1,0,1,0,-1,1,-1,-1,0,-1,1,0,1,1,0,1,-1,0],
+ [-0.774597,-0.774597,-0.774597,-0.774597,-0.774597,0,-0.774597,-0.774597,0.774597,-0.774597,0,-0.774597,-0.774597,0,0,-0.774597,0,0.774597,-0.774597,0.774597,-0.774597,-0.774597,0.774597,0,-0.774597,0.774597,0.774597,0,-0.774597,-0.774597,0,-0.774597,0,0,-0.774597,0.774597,0,0,-0.774597,0,0,0,0,0,0.774597,0,0.774597,-0.774597,0,0.774597,0,0,0.774597,0.774597,0.774597,-0.774597,-0.774597,0.774597,-0.774597,0,0.774597,-0.774597,0.774597,0.774597,0,-0.774597,0.774597,0,0,0.774597,0,0.774597,0.774597,0.774597,-0.774597,0.774597,0.774597,0,0.774597,0.774597,0.774597],
+ [0.171468,0.274348,0.171468,0.274348,0.438957,0.274348,0.171468,0.274348,0.171468,0.274348,0.438957,0.274348,0.438957,0.702332,0.438957,0.274348,0.438957,0.274348,0.171468,0.274348,0.171468,0.274348,0.438957,0.274348,0.171468,0.274348,0.171468])
+ arr=DataArrayDouble(27) ; arr.iota() ; f.setArray(arr)
+ f.checkConsistencyLight()
+ f2=f.voronoize(1e-12)
+ a=0.007187820185770747 ; b=0.0090870678008658 ; c=0.011488156225861077 ; d=0.014523687548277797
+ ref=DataArrayDouble(27) ; ref[::2]=a ; ref[1::2]=b
+ ref[[4,10,12,14,16,22]]=c ; ref[13]=d # 6 cells 4,10,12,14,16,22 are the 6 cells boarding the most inner cell 13
+ #
+ self.assertTrue(f2.getMesh().getMeasureField(False).getArray().isEqual(ref,1e-7))
+ pass
+
def testConvertQuadToLin4Gauss_1(self):
coo=DataArrayDouble([0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,0.0,0.0,0.0,0.5,0.0,0.0,0.0,0.5,0.0,0.5,0.5,0.5,0.5,0.0,0.5,0.0,0.0,0.5,0.0,0.5],10,3)
m=MEDCouplingUMesh("mesh",3)
self.assertEqual(f2.getTime(),[1.,2,3])
pass
- def testBugInComputationOfEqOfPlane1(self):
- coo=DataArrayDouble([-1.0, 1.0, -0.3872983455657959, -1.0, 1.0, 0.3872983455657959, -1.0, 1.0, 0.693649172782898, 1.0, 1.0, 0.693649172782898, 1.0, 1.0, 0.3872983455657959, 1.0, 1.0, -0.3872983455657959],6,3)
- m=MEDCouplingUMesh("",2)
- m.setCoords(coo)
- m.allocateCells()
- m.insertNextCell(NORM_POLYGON,[0,1,2,3,4,5])
- self.assertTrue(m.computePlaneEquationOf3DFaces().isEqual(DataArrayDouble([0,1,0,-1],1,4),1e-12))
+ def testDADCumSum1(self):
+ d=DataArrayDouble([3.,2.,4.,5.])
+ self.assertTrue(d.cumSum().isEqual(DataArrayDouble([0.,3.,5.,9.,14.]),1e-12))
+ d2=DataArrayDouble([])
+ self.assertTrue(d2.cumSum().isEqual(DataArrayDouble([0.]),1e-12))
+ d.rearrange(2)
+ self.assertRaises(InterpKernelException,d.cumSum)
+ pass
+
+ def testDAIFromLinkedListOfPairToList1(self):
+ d=DataArrayInt([(5,7),(7,3),(3,12),(12,17)])
+ zeRes=DataArrayInt([5,7,3,12,17])
+ self.assertTrue(d.fromLinkedListOfPairToList().isEqual(zeRes))
+ d.rearrange(1)
+ self.assertRaises(InterpKernelException,d.fromLinkedListOfPairToList)
+ d.rearrange(2)
+ self.assertTrue(d.fromLinkedListOfPairToList().isEqual(zeRes))
+ d2=DataArrayInt([(5,7)])
+ self.assertTrue(d2.fromLinkedListOfPairToList().isEqual(DataArrayInt([5,7])))
+ d3=DataArrayInt([(5,7),(7,3),(4,12),(12,17)])
+ self.assertRaises(InterpKernelException,d3.fromLinkedListOfPairToList) # not a linked list of pair
+ d4=DataArrayInt([(5,7),(7,3),(12,3),(12,17)])
+ self.assertRaises(InterpKernelException,d4.fromLinkedListOfPairToList) # not a linked list of pair, but can be repaired !
+ d4.sortEachPairToMakeALinkedList()
+ self.assertTrue(d4.fromLinkedListOfPairToList().isEqual(zeRes))
+ pass
+
+ def testUMeshExplodeIntoEdges1(self):
+ m=MEDCouplingCMesh() ; arr=DataArrayDouble(5) ; arr.iota() ; m.setCoords(arr,arr,arr) ; m=m.buildUnstructured()
+ self.assertEqual(m.getMeshDimension(),3)
+ a0,a1,a2,a3,a4=m.explodeIntoEdges()
+ b0,b1,b2,b3,b4=m.explode3DMeshTo1D()
+ self.assertTrue(a0.isEqual(b0,1e-12))
+ self.assertTrue(a1.isEqual(b1)) ; self.assertTrue(a2.isEqual(b2)) ; self.assertTrue(a3.isEqual(b3)) ; self.assertTrue(a4.isEqual(b4))
+ #
+ m=MEDCouplingCMesh() ; arr=DataArrayDouble(5) ; arr.iota() ; m.setCoords(arr,arr) ; m=m.buildUnstructured()
+ self.assertEqual(m.getMeshDimension(),2)
+ a0,a1,a2,a3,a4=m.explodeIntoEdges()
+ b0,b1,b2,b3,b4=m.buildDescendingConnectivity()
+ self.assertTrue(a0.isEqual(b0,1e-12))
+ self.assertTrue(a1.isEqual(b1)) ; self.assertTrue(a2.isEqual(b2)) ; self.assertTrue(a3.isEqual(b3)) ; self.assertTrue(a4.isEqual(b4))
+ pass
+
+ def testUMeshComputeEnlargedNeighborsOfNodes(self):
+ m=MEDCouplingCMesh() ; arr=DataArrayDouble(4) ; arr.iota() ; m.setCoords(arr,arr) ; m=m.buildUnstructured()
+ a,b=m.computeEnlargedNeighborsOfNodes()
+ self.assertTrue(a.isEqual(DataArrayInt([1,4,5,0,2,4,5,6,1,3,5,6,7,2,6,7,0,1,5,8,9,0,1,2,4,6,8,9,10,1,2,3,5,7,9,10,11,2,3,6,10,11,4,5,9,12,13,4,5,6,8,10,12,13,14,5,6,7,9,11,13,14,15,6,7,10,14,15,8,9,13,8,9,10,12,14,9,10,11,13,15,10,11,14])))
+ self.assertTrue(b.isEqual(DataArrayInt([0,3,8,13,16,21,29,37,42,47,55,63,68,71,76,81,84])))
+ pass
+
+ def testDAIfindIdsExt1(self):
+ d=DataArrayInt([4,6,-2,3,7,0,10])
+ self.assertTrue(d.findIdsGreaterOrEqualTo(3).isEqual(DataArrayInt([0,1,3,4,6])))
+ self.assertTrue(d.findIdsGreaterThan(3).isEqual(DataArrayInt([0,1,4,6])))
+ self.assertTrue(d.findIdsLowerThan(3).isEqual(DataArrayInt([2,5])))
+ self.assertTrue(d.findIdsLowerOrEqualTo(3).isEqual(DataArrayInt([2,3,5])))
+ pass
+
+ def testDAFacto1(self):
+ """Test focused of new wrapped methods for MEDCouplingFieldInt thanks to code factorization."""
+ d=DataArrayDouble(7) ; d.iota()
+ m=MEDCouplingUMesh.Build1DMeshFromCoords(d)
+ f=MEDCouplingFieldInt(ON_CELLS) ; f.setMesh(m) ; arr=DataArrayInt(6) ; arr.iota() ; f.setArray(arr) ; f.checkConsistencyLight()
+ f_0=f[::2] # test is here
+ self.assertTrue(f_0.getArray().isEqual(DataArrayInt([0,2,4])))
+ self.assertTrue(f_0.getMesh().isEqual(m[[0,2,4]],1e-12))
+ #
+ f2=MEDCouplingFieldInt(ON_NODES) ; f2.setMesh(m) ; arr=DataArrayInt(7) ; arr.iota() ; f2.setArray(arr) ; f2.checkConsistencyLight()
+ f_1=f2[::2] # test is here
+ self.assertTrue(f_1.getArray().isEqual(DataArrayInt([0,1,2,3,4,5])))
+ m_1=m[[0,2,4]] ; m_1.zipCoords()
+ self.assertTrue(f_1.getMesh().isEqual(m_1,1e-12))
+ pass
+
+ def testFieldFloatIsOnStage1(self):
+ """ My first test with field int."""
+ m=MEDCouplingCMesh()
+ m.setName("mesh")
+ arrX=DataArrayDouble([0,1,2,3])
+ m.setCoords(arrX,arrX)
+ f=MEDCouplingFieldFloat(ON_CELLS)
+ f.setMesh(m)
+ arr=DataArrayFloat(8) ; arr.iota() ;f.setArray(arr)
+ self.assertRaises(InterpKernelException,f.checkConsistencyLight)
+ arr=DataArrayFloat(9) ; arr.iota() ;f.setArray(arr)
+ f.checkConsistencyLight()
+ f.setTimeUnit("ms")
+ self.assertEqual(f.getTimeUnit(),"ms")
+ f.setTime(3.2,5,6)
+ a,b,c=f.getTime()
+ self.assertEqual(b,5)
+ self.assertEqual(c,6)
+ self.assertEqual(a,3.2,12)
+ pass
+
+ def testFieldFloatIsOnStage2(self):
+ """ Very important test to check that isEqual of MEDCouplingFieldFloat is OK !"""
+ m1=MEDCouplingCMesh() ; m1.setCoords(DataArrayDouble([0,1,2,3]),DataArrayDouble([0,1,2,3,4]))
+ m1=m1.buildUnstructured() ; m1.setName("mesh")
+ f1=MEDCouplingFieldFloat(ON_CELLS) ; f1.setMesh(m1)
+ arr1=DataArrayFloat([(0,1),(2,3),(4,5),(6,7),(8,9),(10,11),(12,13),(14,15),(16,17),(18,19),(20,21),(22,23)]) ; arr1.setInfoOnComponents(["aa","bbb"])
+ f1.setArray(arr1) ; f1.setName("f1") ; f1.setTime(2.,3,4)
+ #
+ m2=MEDCouplingCMesh() ; m2.setCoords(DataArrayDouble([0,1,2,3]),DataArrayDouble([0,1,2,3,4]))
+ m2=m2.buildUnstructured() ; m2.setName("mesh")
+ f2=MEDCouplingFieldFloat(ON_CELLS) ; f2.setMesh(m2)
+ arr2=DataArrayFloat([(0,1),(2,3),(4,5),(6,7),(8,9),(10,11),(12,13),(14,15),(16,17),(18,19),(20,21),(22,23)]) ; arr2.setInfoOnComponents(["aa","bbb"])
+ f2.setArray(arr2) ; f2.setName("f1") ; f2.setTime(2.,3,4)
+ #
+ self.assertTrue(f1.isEqual(f2,1e-12,0.))
+ f1.getArray()[:]*=2
+ self.assertTrue(not f1.isEqual(f2,1e-12,0.))
+ self.assertTrue(not f1.isEqualWithoutConsideringStr(f2,1e-12,0.))
+ f1.getArray()[:]/=2
+ self.assertTrue(f1.isEqual(f2,1e-12,0.))
+ #
+ f1.setName("F1")
+ self.assertTrue(not f1.isEqual(f2,1e-12,0.))
+ f1.setName("f1")
+ self.assertTrue(f1.isEqual(f2,1e-12,0.))
+ #
+ f1.getArray().setInfoOnComponents(["aa","bbbb"])
+ self.assertTrue(not f1.isEqual(f2,1e-12,0.))
+ self.assertTrue(f1.isEqualWithoutConsideringStr(f2,1e-12,0.))
+ f1.getArray().setInfoOnComponents(["aa","bbb"])
+ self.assertTrue(f1.isEqual(f2,1e-12,0.))
+ #
+ f3=f2.deepCopy()
+ self.assertTrue(f1.isEqual(f3,1e-12,0.))
+ #
+ for fd,expected in ((ON_NODES,False),(ON_CELLS,True)):
+ f4=MEDCouplingFieldFloat(fd) ; f4.setMesh(m2) ; f4.setTime(2.,3,4)
+ arr4=DataArrayFloat([(0,1),(2,3),(4,5),(6,7),(8,9),(10,11),(12,13),(14,15),(16,17),(18,19),(20,21),(22,23)]) ; arr4.setInfoOnComponents(["aa","bbb"])
+ f4.setArray(arr4) ; f4.setName("f1")
+ self.assertEqual(f1.isEqual(f4,1e-12,0.),expected)
+ pass
+ pass
+
+ def testLTGTDAD1(self):
+ d=DataArrayDouble(10) ; d.iota()
+ self.assertTrue(d.findIdsLowerThan(0).empty())
+ self.assertTrue(d.findIdsLowerThan(1).isEqual(DataArrayInt([0])))
+ d-=5.
+ self.assertTrue(d.findIdsStrictlyNegative().isEqual(DataArrayInt([0,1,2,3,4])))
+ self.assertTrue(d.findIdsGreaterThan(0.).isEqual(DataArrayInt([6,7,8,9])))
+ self.assertTrue(d.convertToFloatArr().isEqual(DataArrayFloat([-5,-4,-3,-2,-1,0,1,2,3,4]),1e-7))
+ self.assertTrue(d.convertToFloatArr().convertToDblArr().isEqual(d,1e-12))
+ pass
+
+ def testMapII1(self):
+ """ Test optimized maps for renumbering. Typical usage local to global in parallel mode"""
+ d=DataArrayInt([1003,1007])
+ m=d.invertArrayN2O2O2NOptimized()
+ d2=DataArrayInt([1003,1003,1007,1003,1007])
+ d2.transformWithIndArr(m)
+ self.assertTrue(d2.isEqual(DataArrayInt([0,0,1,0,1])))
+ pass
+
+ def testDAICheckUniformAndGuess1(self):
+ d=DataArrayInt([3,3],1,2)
+ self.assertRaises(InterpKernelException,d.checkUniformAndGuess)# non single compo
+ d=DataArrayInt([])
+ self.assertRaises(InterpKernelException,d.checkUniformAndGuess)# empty
+ d=DataArrayInt()
+ self.assertRaises(InterpKernelException,d.checkUniformAndGuess)# non allocated
+ d=DataArrayInt([3,3,3])
+ self.assertEqual(3,d.checkUniformAndGuess())
+ d=DataArrayInt([7])
+ self.assertEqual(7,d.checkUniformAndGuess())
+ d=DataArrayInt([3,4,3])
+ self.assertRaises(InterpKernelException,d.checkUniformAndGuess)# non uniform
+ pass
+
+ def testUMComputePlaneEquationOf3DFaces1(self):
+ """ Consequence of an invalid traduction of matrix inversion transposition."""
+ m=MEDCoupling1SGTUMesh("msh",NORM_QUAD4)
+ m.setCoords(DataArrayDouble([(0,0,0),(1,0,0),(2,0,0),(0,2,0),(1,2,0),(2,2,0),(0,4,0),(1,4,0),(2,4,0),(0,0,3),(1,0,3),(2,0,3),(0,2,3),(1,2,3),(2,2,3),(0,4,3),(1,4,3),(2,4,3)]))
+ m.setNodalConnectivity(DataArrayInt([0,1,4,3,9,12,13,10,0,9,10,1,1,10,13,4,4,13,12,3,3,12,9,0,1,2,5,4,10,13,14,11,1,10,11,2,2,11,14,5,5,14,13,4,3,4,7,6,12,15,16,13,4,13,16,7,7,16,15,6,6,15,12,3,4,5,8,7,13,16,17,14,5,14,17,8,8,17,16,7]))
+ m=m.buildUnstructured()
+ ref=DataArrayDouble([(0,0,1,0),(0,0,1,-3),(0,1,0,0),(1,0,0,-1),(0,1,0,-2),(1,0,0,0),(0,0,1,0),(0,0,1,-3),(0,1,0,0),(1,0,0,-2),(0,1,0,-2),(0,0,1,0),(0,0,1,-3),(1,0,0,-1),(0,1,0,-4),(1,0,0,0),(0,0,1,0),(0,0,1,-3),(1,0,0,-2),(0,1,0,-4)])
+ res=m.computePlaneEquationOf3DFaces()
+ self.assertTrue(res.isEqual(ref,1e-12))
pass
pass
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-# Author : Anthony Geay (CEA/DEN)
+# Author : Anthony Geay (EDF R&D)
from MEDLoader import *
import unittest
from MEDLoaderDataForTest import MEDLoaderDataForTest
from distutils.version import LooseVersion
+import sys
+if sys.version_info.major < 3:
+ import cPickle as pickle
+else:
+ import pickle
+
class MEDLoaderTest3(unittest.TestCase):
def testMEDMesh1(self):
fileName="Pyfile18.med"
g1_2=DataArrayInt.New()
g1_2.setValues([1,3],2,1)
g1_2.setName("G1")
-- g2_2=DataArrayInt.New()
++ g2_2=DataArrayInt.New()getCellsContainingPoint
g2_2.setValues([1,2,3],3,1)
g2_2.setName("G2")
mm.setGroupsAtLevel(0,[g1_2,g2_2],False)
g2_1.setName("G2")
mm.setGroupsAtLevel(-1,[g1_1,g2_1],False)
g1_N=DataArrayInt.New()
- g1_N.setValues(range(8),8,1)
+ g1_N.setValues(list(range(8)),8,1)
g1_N.setName("G1")
g2_N=DataArrayInt.New()
- g2_N.setValues(range(9),9,1)
+ g2_N.setValues(list(range(9)),9,1)
g2_N.setName("G2")
mm.setGroupsAtLevel(1,[g1_N,g2_N],False)
mm.createGroupOnAll(0,"GrpOnAllCell")
self.assertTrue(g2_N.isEqual(t));
self.assertTrue(mm.existsGroup("GrpOnAllCell"));
t=mm.getGroupArr(0,"GrpOnAllCell")
- self.assertTrue(t.getValues()==range(5))
+ self.assertTrue(t.getValues()==list(range(5)))
#
mmCpy=mm.deepCopy()
self.assertTrue(mm.isEqual(mmCpy,1e-12)[0]) ; del mm
self.assertTrue(not mm2.existsFamily("Family_-8"))
mm2.createGroupOnAll(-1,"GrpOnAllFace")
self.assertTrue(mm2.existsFamily("Family_-8"))
- self.assertEqual(range(3),mm2.getGroupArr(-1,"GrpOnAllFace").getValues())
+ self.assertEqual(list(range(3)),mm2.getGroupArr(-1,"GrpOnAllFace").getValues())
pass
#testing persistence of retrieved arrays
m.setRenumFieldArr(-1,n1)
m.setRenumFieldArr(-2,n0)
nbOfFams=len(fns)
- for i in xrange(nbOfFams):
+ for i in range(nbOfFams):
m.addFamily(fns[i],fids[i])
pass
nbOfGrps=len(grpns)
- for i in xrange(nbOfGrps):
+ for i in range(nbOfGrps):
m.setFamiliesIdsOnGroup(grpns[i],famIdsPerGrp[i])
pass
m.setName(m2.getName())
m1=MEDLoaderDataForTest.build2DMesh_1()
m1.renumberCells([0,1,4,2,3,5],False)
tmp=m1.getName();
- m1=m1.buildPartOfMySelf(range(5),True) ; m1.setName(tmp) # suppression of last cell that is a polygon
+ m1=m1.buildPartOfMySelf(list(range(5)),True) ; m1.setName(tmp) # suppression of last cell that is a polygon
mm1=MEDFileUMesh.New() ; mm1.setCoords(m1.getCoords()) ; mm1.setMeshAtLevel(0,m1) ;
mm1.write(fname,2)
ff1=MEDFileField1TS.New()
m1=MEDLoaderDataForTest.build2DMesh_1()
m1.renumberCells([0,1,4,2,3,5],False)
tmp=m1.getName();
- m1=m1.buildPartOfMySelf(range(5),True) ; m1.setName(tmp) # suppression of last cell that is a polygon
+ m1=m1.buildPartOfMySelf(list(range(5)),True) ; m1.setName(tmp) # suppression of last cell that is a polygon
mm1=MEDFileUMesh.New() ; mm1.setCoords(m1.getCoords()) ; mm1.setMeshAtLevel(0,m1) ;
mm1.write(fname,2)
ff1=MEDFileFieldMultiTS.New()
da=DataArrayInt.New(); da.setValues([0,1,3,4,6],5,1) ; da.setName("sup1NodeElt")
#
ff1.setFieldProfile(f1,mm1,0,da)
- m1=m0.buildPartOfMySelf(range(5),True) ; m1.setName(tmp) ; mm1.setMeshAtLevel(0,m1) ;
+ m1=m0.buildPartOfMySelf(list(range(5)),True) ; m1.setName(tmp) ; mm1.setMeshAtLevel(0,m1) ;
mm1.write(fname,2)
ff1.write(fname,0)
f1=ff1.getFieldOnMeshAtLevel(ON_GAUSS_NE,m1,0)
expected1=[1.,10.,100.,2.,20.,200.]
nodeCoordsWithValue1=[10.,2.5,0.]
nodeCoordsWithValue2=[10.,3.75,0.]
- for i in xrange(3):
+ for i in range(3):
self.assertAlmostEqual(nodeCoordsWithValue1[i],tes0.getMesh().getCoordinatesOfNode(0)[i],13);
self.assertAlmostEqual(nodeCoordsWithValue2[i],tes0.getMesh().getCoordinatesOfNode(1)[i],13);
pass
- for i in xrange(6):
+ for i in range(6):
self.assertAlmostEqual(expected1[i],tes0.getArray().getIJ(0,i),13);
pass
del tes0
self.assertEqual([0,2,4],tes1.getMesh().getNodalConnectivityIndex().getValues())
self.assertEqual(2,tes1.getArray().getNumberOfTuples())
self.assertEqual(3,tes1.getArray().getNumberOfComponents())
- for i in xrange(6):
+ for i in range(6):
self.assertAlmostEqual(expected1[i],tes1.getArray().getIJ(0,i),13);
pass
m.write(fname,2)
self.assertEqual(2,tes2.getArray().getNumberOfTuples())
self.assertEqual(3,tes2.getArray().getNumberOfComponents())
expected2=[2.,20.,200.,1.,10.,100.]
- for i in xrange(3):
+ for i in range(3):
self.assertAlmostEqual(nodeCoordsWithValue1[i],tes2.getMesh().getCoordinatesOfNode(0)[i],13);
self.assertAlmostEqual(nodeCoordsWithValue2[i],tes2.getMesh().getCoordinatesOfNode(1)[i],13);
pass
- for i in xrange(6):
+ for i in range(6):
self.assertAlmostEqual(expected2[i],tes2.getArray().getIJ(0,i),13);#compare tes2 and tes3
pass
#
self.assertEqual([0,2,4],tes3.getMesh().getNodalConnectivityIndex().getValues())
self.assertEqual(2,tes3.getArray().getNumberOfTuples())
self.assertEqual(3,tes3.getArray().getNumberOfComponents())
- for i in xrange(6):
+ for i in range(6):
self.assertAlmostEqual(expected1[i],tes3.getArray().getIJ(0,i),13);
pass
pass
coords=DataArrayDouble([0.,0.,0.,1.,1.,1.,1.,0.,0.,0.5,0.5,1.,1.,0.5,0.5,0.],8,2)
mQ8=MEDCouplingUMesh("",2) ; mQ8.setCoords(coords)
mQ8.allocateCells(1)
- mQ8.insertNextCell(NORM_QUAD8,range(8))
+ mQ8.insertNextCell(NORM_QUAD8,list(range(8)))
mQ8.finishInsertingCells()
mQ4=MEDCouplingUMesh("",2) ; mQ4.setCoords(coords)
mQ4.allocateCells(1)
- mQ4.insertNextCell(NORM_QUAD4,range(4))
+ mQ4.insertNextCell(NORM_QUAD4,list(range(4)))
mQ4.finishInsertingCells()
mT3=MEDCouplingUMesh("",2) ; mT3.setCoords(coords)
mT3.allocateCells(1)
- mT3.insertNextCell(NORM_TRI3,range(3))
+ mT3.insertNextCell(NORM_TRI3,list(range(3)))
mT3.finishInsertingCells()
tr=[[0.,4.],[2.,4.],[4.,4.],[6.,4.],[8.,4.],[10.,4.],[12.,4.],[14.,4.],[16.,4.],[18.,4.],[20.,4.],[0.,0.],[2.,0.], [0.,2.],[2.,2.],[4.,2.],[6.,2.],[8.,2.],[10.,2.],[12.,2.]]
mm.write(fname,2)
#
f1ts=MEDFileField1TS.New()
- pfl=DataArrayInt(range(13)) ; pfl.setName("pfl")
+ pfl=DataArrayInt(list(range(13))) ; pfl.setName("pfl")
self.assertRaises(InterpKernelException,f1ts.setFieldProfile,fInvalid,mm,0,pfl) # fails because no Gauss localization per cell set !
self.assertRaises(InterpKernelException,f1ts.setFieldProfile,fInvalid2,mm,0,pfl) # fails because no Gauss localization set whereas gauss locid per cell given !
f1ts.setFieldProfile(f,mm,0,pfl)
m1=MEDCouplingUMesh(m0.getName(),1)
m1.allocateCells(9)
conn1=[0,1,0,3,3,4,4,1,5,4,2,4,1,2,3,6,5,8]
- for i in xrange(9):
+ for i in range(9):
m1.insertNextCell(NORM_SEG2,conn1[2*i:2*i+2])
pass
m1.finishInsertingCells()
m1=MEDCouplingUMesh(m0.getName(),1)
m1.allocateCells(9)
conn1=[0,1,0,3,3,4,4,1,5,4,2,4,1,2,3,6,5,8]
- for i in xrange(9):
+ for i in range(9):
m1.insertNextCell(NORM_SEG2,conn1[2*i:2*i+2])
pass
m1.finishInsertingCells()
m=MEDFileUMesh()
coo=DataArrayDouble(9) ; coo.iota(1.) ; coo.rearrange(3) ; coo.setInfoOnComponents(["aaa [b]","cc [dd]", "e [fff]"])
m0=MEDCouplingUMesh("toto",2) ; m0.allocateCells(0)
- for i in xrange(7):
+ for i in range(7):
m0.insertNextCell(NORM_TRI3,[1,2,1])
pass
- for i in xrange(4):
+ for i in range(4):
m0.insertNextCell(NORM_QUAD4,[1,1,2,0])
pass
- for i in xrange(2):
+ for i in range(2):
m0.insertNextCell(NORM_POLYGON,[0,0,1,1,2,2])
pass
m1=MEDCouplingUMesh("toto",1) ; m1.allocateCells(0) ; m1.insertNextCell(NORM_SEG2,[1,6]) ; m1.insertNextCell(NORM_SEG2,[7,3])
m=m.buildUnstructured()
m.setName("mm")
f=m.getMeasureField(False)
- self.assertIn(m.getHeapMemorySize(),xrange(3552-100,3552+100+4*strMulFac))
- self.assertIn(f.getHeapMemorySize(),xrange(4215-100,4215+100+8*strMulFac))
+ self.assertIn(m.getHeapMemorySize(), list(range(3552 - 100, 3552 + 100 + 4 * strMulFac)))
+ self.assertIn(f.getHeapMemorySize(), list(range(4215 - 100, 4215 + 100 + 8 * strMulFac)))
#
mm=MEDFileUMesh()
mm.setMeshAtLevel(0,m)
- self.assertIn(mm.getHeapMemorySize(),xrange(3889-100,4225+100+10*strMulFac))
+ self.assertIn(mm.getHeapMemorySize(), list(range(3889 - 100, 4225 + 100 + 10 * strMulFac)))
ff=MEDFileField1TS()
ff.setFieldNoProfileSBT(f)
- self.assertIn(ff.getHeapMemorySize(),xrange(771-40,871+21+(4+1)*strMulFac))
+ self.assertIn(ff.getHeapMemorySize(), list(range(771 - 40, 871 + 21 + (4 + 1) * strMulFac)))
#
fff=MEDFileFieldMultiTS()
fff.appendFieldNoProfileSBT(f)
- self.assertIn(fff.getHeapMemorySize(),xrange(815-50,915+30+(6+2)*strMulFac))
+ self.assertIn(fff.getHeapMemorySize(), list(range(815 - 50, 915 + 30 + (6 + 2) * strMulFac)))
f.setTime(1.,0,-1)
fff.appendFieldNoProfileSBT(f)
- self.assertIn(fff.getHeapMemorySize(),xrange(1594-90,1794+50+(10+1)*strMulFac))
- self.assertIn(fff[0,-1].getHeapMemorySize(),xrange(771-40,871+20+(4+1)*strMulFac))
+ self.assertIn(fff.getHeapMemorySize(), list(range(1594 - 90, 1794 + 50 + (10 + 1) * strMulFac)))
+ self.assertIn(fff[0, -1].getHeapMemorySize(), list(range(771 - 40, 871 + 20 + (4 + 1) * strMulFac)))
f2=f[:50]
f2.setTime(2.,1,-1)
pfl=DataArrayInt.Range(0,50,1) ; pfl.setName("pfl")
fff.appendFieldProfile(f2,mm,0,pfl)
- self.assertIn(fff.getHeapMemorySize(),xrange(2348-130,2608+100+(10+2)*strMulFac))
- self.assertIn(fff.getProfile("pfl").getHeapMemorySize(),xrange(204-10,204+10+2*strMulFac))
- self.assertIn(fff[1,-1].getHeapMemorySize(),xrange(738-50,838+30+4*strMulFac))
+ self.assertIn(fff.getHeapMemorySize(), list(range(2348 - 130, 2608 + 100 + (10 + 2) * strMulFac)))
+ self.assertIn(fff.getProfile("pfl").getHeapMemorySize(), list(range(204 - 10, 204 + 10 + 2 * strMulFac)))
+ self.assertIn(fff[1, -1].getHeapMemorySize(), list(range(738 - 50, 838 + 30 + 4 * strMulFac)))
pass
def testCurveLinearMesh1(self):
mm.setMeshAtLevel(0,m)
mm.setMeshAtLevel(-1,m1)
namesCellL0=DataArrayAsciiChar(6,16)
- namesCellL0[:]=["CellL0#%.3d "%(i) for i in xrange(6)]
+ namesCellL0[:] = ["CellL0#%.3d " % (i) for i in range(6)]
mm.setNameFieldAtLevel(0,namesCellL0)
namesCellL1=DataArrayAsciiChar.Aggregate([namesCellL0,namesCellL0,namesCellL0.subArray(2)])
- namesCellL1[:]=["CellLM1#%.3d "%(i) for i in xrange(16)]
+ namesCellL1[:] = ["CellLM1#%.3d " % (i) for i in range(16)]
mm.setNameFieldAtLevel(-1,namesCellL1)
namesNodes=namesCellL1.subArray(4,16)
- namesNodes[:]=["Node#%.3d "%(i) for i in xrange(12)]
+ namesNodes[:] = ["Node#%.3d " % (i) for i in range(12)]
mm.setNameFieldAtLevel(1,namesNodes)
mm.write(fname,2)
#
mmr=MEDFileMesh.New(fname)
- self.assertTrue(mm.getNameFieldAtLevel(0).isEqual(DataArrayAsciiChar(["CellL0#%.3d "%(i) for i in xrange(6)])))
- self.assertTrue(mm.getNameFieldAtLevel(-1).isEqual(DataArrayAsciiChar(["CellLM1#%.3d "%(i) for i in xrange(16)])))
- self.assertTrue(mm.getNameFieldAtLevel(1).isEqual(DataArrayAsciiChar(["Node#%.3d "%(i) for i in xrange(12)])))
+ self.assertTrue(mm.getNameFieldAtLevel(0).isEqual(DataArrayAsciiChar(["CellL0#%.3d " % (i) for i in range(6)])))
+ self.assertTrue(mm.getNameFieldAtLevel(-1).isEqual(DataArrayAsciiChar(["CellLM1#%.3d " % (i) for i in range(16)])))
+ self.assertTrue(mm.getNameFieldAtLevel(1).isEqual(DataArrayAsciiChar(["Node#%.3d " % (i) for i in range(12)])))
self.assertTrue(mm.isEqual(mmr,1e-12)[0])
mmr.getNameFieldAtLevel(1).setIJ(0,0,'M')
self.assertTrue(not mm.isEqual(mmr,1e-12)[0])
mm.write(fname,2)
mmr=MEDFileMesh.New(fname)
self.assertEqual(mmr.getNameFieldAtLevel(1),None)
- self.assertTrue(mmr.getNameFieldAtLevel(0).isEqual(DataArrayAsciiChar(["CellL0#%.3d "%(i) for i in xrange(6)])))
+ self.assertTrue(mmr.getNameFieldAtLevel(0).isEqual(DataArrayAsciiChar(["CellL0#%.3d " % (i) for i in range(6)])))
self.assertEqual(mmr.getNameFieldAtLevel(-1),None)
#
c=MEDCouplingCMesh()
c.setName("cmesh")
cc=MEDFileCMesh()
cc.setMesh(c)
- cc.setNameFieldAtLevel(0,DataArrayAsciiChar(["Cell#%.3d "%(i) for i in xrange(4)]))
- cc.setNameFieldAtLevel(1,DataArrayAsciiChar(["Node#%.3d "%(i) for i in xrange(9)]))
+ cc.setNameFieldAtLevel(0, DataArrayAsciiChar(["Cell#%.3d " % (i) for i in range(4)]))
+ cc.setNameFieldAtLevel(1, DataArrayAsciiChar(["Node#%.3d " % (i) for i in range(9)]))
cc.write(fname2,2)
ccr=MEDFileMesh.New(fname2)
- self.assertTrue(ccr.getNameFieldAtLevel(0).isEqual(DataArrayAsciiChar(["Cell#%.3d "%(i) for i in xrange(4)])))
- self.assertTrue(ccr.getNameFieldAtLevel(1).isEqual(DataArrayAsciiChar(["Node#%.3d "%(i) for i in xrange(9)])))
+ self.assertTrue(ccr.getNameFieldAtLevel(0).isEqual(DataArrayAsciiChar(["Cell#%.3d " % (i) for i in range(4)])))
+ self.assertTrue(ccr.getNameFieldAtLevel(1).isEqual(DataArrayAsciiChar(["Node#%.3d " % (i) for i in range(9)])))
self.assertTrue(cc.isEqual(ccr,1e-12)[0])
ccr.getNameFieldAtLevel(1).setIJ(0,0,'M')
self.assertTrue(not cc.isEqual(ccr,1e-12)[0])
m.setFamilyFieldArr(-2,f0)
m.setFamilyFieldArr(1,p)
nbOfFams=len(fns)
- for i in xrange(nbOfFams):
+ for i in range(nbOfFams):
m.addFamily(fns[i],fids[i])
pass
nbOfGrps=len(grpns)
- for i in xrange(nbOfGrps):
+ for i in range(nbOfGrps):
m.setFamiliesIdsOnGroup(grpns[i],famIdsPerGrp[i])
pass
m.setName(m2.getName())
nf1=MEDCouplingFieldInt(ON_NODES)
nf1.setTime(9.,10,-1)
nf1.setMesh(f1.getMesh())
- narr=DataArrayInt(12,2) ; narr.setInfoOnComponents(["aa [u1]","bbbvv [ppp]"]) ; narr[:,0]=range(12) ; narr[:,1]=2*narr[:,0]
+ narr=DataArrayInt(12,2) ; narr.setInfoOnComponents(["aa [u1]","bbbvv [ppp]"]) ; narr[:,0]=list(range(12)) ; narr[:,1]=2*narr[:,0]
nf1.setName("VectorFieldOnNodes") ; nf1.setArray(narr)
nff1=MEDFileIntField1TS.New()
nff1.setFieldNoProfileSBT(nf1)
nf2=MEDCouplingFieldInt(ON_NODES)
nf2.setTime(19.,20,-11)
nf2.setMesh(f1.getMesh())
- narr2=DataArrayInt(8,2) ; narr.setInfoOnComponents(["aapfl [u1]","bbbvvpfl [ppp]"]) ; narr2[:,0]=range(8) ; narr2[:,0]+=10 ; narr2[:,1]=3*narr2[:,0]
+ narr2=DataArrayInt(8,2) ; narr.setInfoOnComponents(["aapfl [u1]","bbbvvpfl [ppp]"]) ; narr2[:,0]=list(range(8)) ; narr2[:,0]+=10 ; narr2[:,1]=3*narr2[:,0]
nf2.setName("VectorFieldOnNodesPfl") ; narr2.setName(nf2.getName()) ; nf2.setArray(narr2)
nff2=MEDFileIntField1TS.New()
npfl=DataArrayInt([1,2,4,5,6,7,10,11]) ; npfl.setName("npfl")
c=DataArrayDouble(12) ; c.iota(); m=MEDCouplingCMesh() ; m.setCoordsAt(0,c) ; m.setName("mesh")
mm=MEDFileCMesh() ; mm.setMesh(m) ; mm.write(fname,2)
f1.setMesh(m)
- arr=DataArrayDouble(12,2) ; arr.setInfoOnComponents(["aa [u1]","bbbvv [ppp]"]) ; arr[:,0]=range(12) ; arr[:,1]=2*arr[:,0]
+ arr=DataArrayDouble(12,2) ; arr.setInfoOnComponents(["aa [u1]","bbbvv [ppp]"]) ; arr[:,0]=list(range(12)) ; arr[:,1]=2*arr[:,0]
f1.setArray(arr)
f1.setName("Field1")
ff1=MEDFileField1TS.New()
tri=MEDCouplingUMesh("tri",2)
tri.allocateCells() ; tri.insertNextCell(NORM_TRI3,[0,1,2])
tri.setCoords(DataArrayDouble([(0.,0.),(0.,1.),(1.,0.)]))
- tris=[tri.deepCopy() for i in xrange(4)]
+ tris = [tri.deepCopy() for i in range(4)]
for i,elt in enumerate(tris): elt.translate([i,0])
tris=MEDCouplingUMesh.MergeUMeshes(tris)
quad=MEDCouplingUMesh("quad",2)
quad.allocateCells() ; quad.insertNextCell(NORM_QUAD4,[0,1,2,3])
quad.setCoords(DataArrayDouble([(0.,0.),(0.,1.),(1.,1.),(1.,0.)]))
- quads=[quad.deepCopy() for i in xrange(5)]
+ quads = [quad.deepCopy() for i in range(5)]
for i,elt in enumerate(quads): elt.translate([5+i,0])
quads=MEDCouplingUMesh.MergeUMeshes(quads)
m=MEDCouplingUMesh.MergeUMeshes(tris,quads)
fmts0_0=MEDFileFieldMultiTS()
fmts0_1=MEDFileFieldMultiTS()
# time steps
- for i in xrange(10):
+ for i in range(10):
infos1=["aa [bb]","ccc [ddd]"] ; name1="1stField"
d=DataArrayDouble(18) ; d.iota(i*10) ; d.rearrange(2) ; d.setInfoOnComponents(infos1)
f=MEDCouplingFieldDouble(ON_CELLS) ; f.setName(name1) ; f.setArray(d) ; f.setMesh(m)
tri=MEDCouplingUMesh("tri",2)
tri.allocateCells() ; tri.insertNextCell(NORM_TRI3,[0,1,2])
tri.setCoords(DataArrayDouble([(0.,0.),(0.,1.),(1.,0.)]))
- tris=[tri.deepCopy() for i in xrange(4)]
+ tris = [tri.deepCopy() for i in range(4)]
for i,elt in enumerate(tris): elt.translate([i,0])
tris=MEDCouplingUMesh.MergeUMeshes(tris)
quad=MEDCouplingUMesh("quad",2)
quad.allocateCells() ; quad.insertNextCell(NORM_QUAD4,[0,1,2,3])
quad.setCoords(DataArrayDouble([(0.,0.),(0.,1.),(1.,1.),(1.,0.)]))
- quads=[quad.deepCopy() for i in xrange(5)]
+ quads = [quad.deepCopy() for i in range(5)]
for i,elt in enumerate(quads): elt.translate([5+i,0])
quads=MEDCouplingUMesh.MergeUMeshes(quads)
m=MEDCouplingUMesh.MergeUMeshes(tris,quads)
fmts0_0=MEDFileFieldMultiTS()
fmts0_1=MEDFileFieldMultiTS()
# time steps
- for i in xrange(10):
+ for i in range(10):
infos1=["aa [bb]","ccc [ddd]"] ; name1="1stField"
d=DataArrayDouble(14) ; d.iota(i*10) ; d.rearrange(2) ; d.setInfoOnComponents(infos1)
f=MEDCouplingFieldDouble(ON_CELLS) ; f.setName(name1) ; f.setArray(d) ; f.setMesh(m)
self.assertEqual(fs0.getPfls(),('pfl_NORM_QUAD4',))
#
fmts0_5=MEDFileFieldMultiTS()
- for i in xrange(7):
+ for i in range(7):
infos1=["aa [bb]","ccc [ddd]"] ; name1="1stField"
d=DataArrayDouble(16) ; d.iota(i*10) ; d.rearrange(2) ; d.setInfoOnComponents(infos1)
f=MEDCouplingFieldDouble(ON_CELLS) ; f.setName(name1) ; f.setArray(d) ; f.setMesh(m)
tri=MEDCouplingUMesh("tri",2)
tri.allocateCells() ; tri.insertNextCell(NORM_TRI3,[0,1,2])
tri.setCoords(DataArrayDouble([(0.,0.),(0.,1.),(1.,0.)]))
- tris=[tri.deepCopy() for i in xrange(4)]
+ tris = [tri.deepCopy() for i in range(4)]
for i,elt in enumerate(tris): elt.translate([i,0])
tris=MEDCouplingUMesh.MergeUMeshes(tris)
quad=MEDCouplingUMesh("quad",2)
quad.allocateCells() ; quad.insertNextCell(NORM_QUAD4,[0,1,2,3])
quad.setCoords(DataArrayDouble([(0.,0.),(0.,1.),(1.,1.),(1.,0.)]))
- quads=[quad.deepCopy() for i in xrange(5)]
+ quads = [quad.deepCopy() for i in range(5)]
for i,elt in enumerate(quads): elt.translate([5+i,0])
quads=MEDCouplingUMesh.MergeUMeshes(quads)
m=MEDCouplingUMesh.MergeUMeshes(tris,quads)
fmts0_1=MEDFileFieldMultiTS()
# time steps
infos1=['aa [bb]','ccc [ddd]',"ZZZZ [MW*s]"]
- for i in xrange(10):
+ for i in range(10):
name1="1stField"
d=DataArrayDouble(21) ; d.iota(i*10) ; d.rearrange(3) ; d.setInfoOnComponents(infos1)
f=MEDCouplingFieldDouble(ON_CELLS) ; f.setName(name1) ; f.setArray(d) ; f.setMesh(m)
self.assertEqual(fs1.getPfls(),('pfl_NORM_QUAD4',))
self.assertEqual(fs1.getPflsReallyUsed(),('pfl_NORM_QUAD4',))
self.assertEqual(4,len(fs1))
- for i in xrange(10):
+ for i in range(10):
for j,fieldName in enumerate(['1stField_aa','1stField_ccc','1stField_ZZZZ']):
f1ts=fs1[fieldName][i]
f=f1ts.getFieldOnMeshAtLevel(ON_CELLS,0,mm)
tri=MEDCouplingUMesh("tri",2)
tri.allocateCells() ; tri.insertNextCell(NORM_TRI3,[0,1,2])
tri.setCoords(DataArrayDouble([(0.,0.),(0.,1.),(1.,0.)]))
- tris=[tri.deepCopy() for i in xrange(4)]
+ tris = [tri.deepCopy() for i in range(4)]
for i,elt in enumerate(tris): elt.translate([i,0])
tris=MEDCouplingUMesh.MergeUMeshes(tris)
quad=MEDCouplingUMesh("quad",2)
quad.allocateCells() ; quad.insertNextCell(NORM_QUAD4,[0,1,2,3])
quad.setCoords(DataArrayDouble([(0.,0.),(0.,1.),(1.,1.),(1.,0.)]))
- quads=[quad.deepCopy() for i in xrange(5)]
+ quads = [quad.deepCopy() for i in range(5)]
for i,elt in enumerate(quads): elt.translate([5+i,0])
quads=MEDCouplingUMesh.MergeUMeshes(quads)
m=MEDCouplingUMesh.MergeUMeshes(tris,quads)
tri=MEDCouplingUMesh("tri",2)
tri.allocateCells() ; tri.insertNextCell(NORM_TRI3,[0,1,2])
tri.setCoords(DataArrayDouble([(0.,0.),(0.,1.),(1.,0.)]))
- tris=[tri.deepCopy() for i in xrange(30)]
+ tris = [tri.deepCopy() for i in range(30)]
for i,elt in enumerate(tris): elt.translate([i,0])
tris=MEDCouplingUMesh.MergeUMeshes(tris)
quad=MEDCouplingUMesh("quad",2)
quad.allocateCells() ; quad.insertNextCell(NORM_QUAD4,[0,1,2,3])
quad.setCoords(DataArrayDouble([(0.,0.),(0.,1.),(1.,1.),(1.,0.)]))
- quads=[quad.deepCopy() for i in xrange(40)]
+ quads = [quad.deepCopy() for i in range(40)]
for i,elt in enumerate(quads): elt.translate([40+i,0])
quads=MEDCouplingUMesh.MergeUMeshes(quads)
m=MEDCouplingUMesh.MergeUMeshes(tris,quads)
self.assertTrue(not ff0.getUndergroundDataArray().isAllocated())
self.assertEqual(ff0.getUndergroundDataArray().getInfoOnComponents(),['X [km]','YY [mm]'])
heap_memory_ref=ff0.getHeapMemorySize()
- self.assertIn(heap_memory_ref,xrange(182,465+3*strMulFac))
+ self.assertIn(heap_memory_ref, list(range(182, 540 + 2 * strMulFac)))
ff0.loadArrays() ##
arr=DataArrayDouble(140) ; arr.iota() ; arr.rearrange(2)
self.assertTrue(ff0.getUndergroundDataArray().isEqualWithoutConsideringStr(arr,1e-14))
ff0=MEDFileField1TS(fname,"FieldCellPfl",False)
self.assertEqual(ff0.getUndergroundDataArray().getInfoOnComponents(),["XX [pm]","YYY [hm]"])
heap_memory_ref=ff0.getHeapMemorySize()
- self.assertIn(heap_memory_ref,xrange(350,520+7*strMulFac))
+ self.assertIn(heap_memory_ref, list(range(350, 600 + 6 * strMulFac)))
ff0.loadArrays() ##
arr=DataArrayDouble(100) ; arr.iota() ; arr.rearrange(2)
self.assertTrue(ff0.getUndergroundDataArray().isEqualWithoutConsideringStr(arr,1e-14))
self.assertEqual(ff0.getUndergroundDataArray().getIJ(30,1),5.5)
self.assertTrue(not ff0.getUndergroundDataArray().isEqualWithoutConsideringStr(arr,1e-14))
heap_memory_ref=ff0.getHeapMemorySize()
- self.assertIn(heap_memory_ref,xrange(1100,1384+3*strMulFac))
+ self.assertIn(heap_memory_ref, list(range(1100, 1400 + 2 * strMulFac)))
ff0.unloadArrays()
hmd=ff0.getHeapMemorySize()-heap_memory_ref
self.assertEqual(hmd,-800) # -50*8*2
#
ff0=MEDFileField1TS(fname,"FieldCellPfl",-1,-1,False)
heap_memory_ref=ff0.getHeapMemorySize()
- self.assertIn(heap_memory_ref,xrange(299,520+7*strMulFac))
+ self.assertIn(heap_memory_ref, list(range(299, 620 + 6 * strMulFac)))
ff0.loadArrays() ##
self.assertTrue(ff0.getUndergroundDataArray().isEqualWithoutConsideringStr(arr,1e-14))
self.assertEqual(ff0.getHeapMemorySize()-heap_memory_ref,50*8*2)
#
fieldName="FieldCellMultiTS"
ff0=MEDFileFieldMultiTS()
- for t in xrange(20):
+ for t in range(20):
f0=MEDCouplingFieldDouble(ON_CELLS,ONE_TIME) ; f0.setMesh(m) ; arr=DataArrayDouble(m.getNumberOfCells()*2) ; arr.iota(float(t+1000)) ; arr.rearrange(2) ; arr.setInfoOnComponents(["X [km]","YY [mm]"]) ; f0.setArray(arr) ; f0.setName(fieldName)
f0.setTime(float(t)+0.1,t,100+t)
f0.checkConsistencyLight()
#
ff0=MEDFileAnyTypeFieldMultiTS.New(fname,fieldName,False)
heap_memory_ref=ff0.getHeapMemorySize()
- self.assertIn(heap_memory_ref,xrange(5536,8212+(80+26+1+len(ff0))*strMulFac))
+ self.assertIn(heap_memory_ref, list(range(5536, 9212 + (80 + 26 + 1) * strMulFac)))
ff0.loadArrays()
self.assertEqual(ff0.getHeapMemorySize()-heap_memory_ref,20*70*8*2)
del ff0
#
ffs=MEDFileFields(fname,False)
heap_memory_ref=ffs.getHeapMemorySize()
- self.assertIn(heap_memory_ref,xrange(5335,9031+(80+50+24+len(ffs))*strMulFac))
+ self.assertIn(heap_memory_ref, list(range(5335, 10031 + (80 + 50 + len(ffs)) * strMulFac)))
ffs.loadArrays()
self.assertEqual(ffs.getHeapMemorySize()-heap_memory_ref,20*70*8*2+70*8*2+50*8*2)
pass
tri=MEDCouplingUMesh("tri",2)
tri.allocateCells() ; tri.insertNextCell(NORM_TRI3,[0,1,2])
tri.setCoords(DataArrayDouble([(0.,0.),(0.,1.),(1.,0.)]))
- tris=[tri.deepCopy() for i in xrange(4)]
+ tris = [tri.deepCopy() for i in range(4)]
for i,elt in enumerate(tris): elt.translate([i,0])
tris=MEDCouplingUMesh.MergeUMeshes(tris)
quad=MEDCouplingUMesh("quad",2)
quad.allocateCells() ; quad.insertNextCell(NORM_QUAD4,[0,1,2,3])
quad.setCoords(DataArrayDouble([(0.,0.),(0.,1.),(1.,1.),(1.,0.)]))
- quads=[quad.deepCopy() for i in xrange(5)]
+ quads = [quad.deepCopy() for i in range(5)]
for i,elt in enumerate(quads): elt.translate([5+i,0])
quads=MEDCouplingUMesh.MergeUMeshes(quads)
m=MEDCouplingUMesh.MergeUMeshes(tris,quads)
tri=MEDCouplingUMesh("tri",2)
tri.allocateCells() ; tri.insertNextCell(NORM_TRI3,[0,1,2])
tri.setCoords(DataArrayDouble([(0.,0.),(0.,1.),(1.,0.)]))
- tris=[tri.deepCopy() for i in xrange(4)]
+ tris = [tri.deepCopy() for i in range(4)]
for i,elt in enumerate(tris): elt.translate([i,0])
tris=MEDCouplingUMesh.MergeUMeshes(tris)
quad=MEDCouplingUMesh("quad",2)
quad.allocateCells() ; quad.insertNextCell(NORM_QUAD4,[0,1,2,3])
quad.setCoords(DataArrayDouble([(0.,0.),(0.,1.),(1.,1.),(1.,0.)]))
- quads=[quad.deepCopy() for i in xrange(5)]
+ quads = [quad.deepCopy() for i in range(5)]
for i,elt in enumerate(quads): elt.translate([5+i,0])
quads=MEDCouplingUMesh.MergeUMeshes(quads)
m=MEDCouplingUMesh.MergeUMeshes(tris,quads)
m00=MEDCouplingUMesh("mesh",1) ; m00.setCoords(m0.getCoords()) ; m00.allocateCells(0)
m=MEDFileUMesh()
m.setMeshAtLevel(0,m00)
- m.setRenumFieldArr(1,DataArrayInt(range(10,26)))
+ m.setRenumFieldArr(1,DataArrayInt(list(range(10,26))))
m.setFamilyFieldArr(1,DataArrayInt([-1,-1,-1,-1,-1,-2,-2,-2,-2,-2,-2,0,-1,-3,-3,-3]))
m.write(fname,2)
del m,a,c,m0,m00
m=MEDFileMesh.New(fname)
self.assertEqual((),m.getNonEmptyLevels())
self.assertTrue(m.getCoords().isEqual(DataArrayDouble([(0,0),(1,0),(2,0),(3,0),(0,1),(1,1),(2,1),(3,1),(0,2),(1,2),(2,2),(3,2),(0,3),(1,3),(2,3),(3,3)]),1e-12))
- self.assertTrue(m.getNumberFieldAtLevel(1).isEqual(DataArrayInt(range(10,26))))
+ self.assertTrue(m.getNumberFieldAtLevel(1).isEqual(DataArrayInt(list(range(10,26)))))
self.assertTrue(m.getFamilyFieldAtLevel(1).isEqual(DataArrayInt([-1,-1,-1,-1,-1,-2,-2,-2,-2,-2,-2,0,-1,-3,-3,-3])))
pass
m.insertNextCell([0,2,1,3])
m.setCoords(DataArrayDouble([0.,0.,1.,1.,1.,0.,0.,1.],4,2))
#
- ms=[m.deepCopy() for i in xrange(4)]
+ ms = [m.deepCopy() for i in range(4)]
for i,elt in enumerate(ms):
elt.translate([float(i)*1.5,0.])
pass
m0=MEDCoupling1SGTUMesh.Merge1SGTUMeshes(ms).buildUnstructured()
m0.convertAllToPoly()
#
- ms=[m.deepCopy() for i in xrange(5)]
+ ms = [m.deepCopy() for i in range(5)]
for i,elt in enumerate(ms):
elt.translate([float(i)*1.5,1.5])
pass
#
fmts=MEDFileFieldMultiTS()
#
- for i in xrange(nbCells):
+ for i in range(nbCells):
t=(float(i)+0.1,i+1,-i-2)
f.setTime(*t)
arr2=DataArrayDouble(nbCells)
renum0=DataArrayInt([3,6,7,10,11,0,2,1,9,8,5,4,12,13,14,24,23,22,21,20,19,18,17,16,15])
famField0=DataArrayInt([-3,-6,-7,-10,-11,0,-2,-1,-9,-8,-5,-4,-12,-13,-14,-24,-23,-22,-21,-20,-19,-18,-17,-16,-15])
namesCellL0=DataArrayAsciiChar(25,16)
- namesCellL0[:]=["Cell#%.3d "%(i) for i in xrange(25)]
+ namesCellL0[:] = ["Cell#%.3d " % (i) for i in range(25)]
renumM1=DataArrayInt([3,4,0,2,1])
famFieldM1=DataArrayInt([-3,-4,0,-2,-1])
mm.setRenumFieldArr(0,renum0)
renum1=DataArrayInt([13,16,17,20,21,10,12,11,19,18,15,14,22,23,24,34,33,32,31,30,29,28,27,26,25,45,44,43,42,41,40,39,38,37,36,35])
famField1=DataArrayInt([-13,-16,-17,-20,-21,-10,-12,-11,-19,-18,-15,-14,-22,-23,-24,-34,-33,-32,-31,-30,-29,-28,-27,-26,-25,-45,-44,-43,-42,-41,-40,-39,-38,-37,-36,-35])
namesNodes=DataArrayAsciiChar(36,16)
- namesNodes[:]=["Node#%.3d "%(i) for i in xrange(36)]
+ namesNodes[:] = ["Node#%.3d " % (i) for i in range(36)]
mm.setRenumFieldArr(1,renum1)
mm.setFamilyFieldArr(1,famField1)
mm.setNameFieldAtLevel(1,namesNodes)
f=MEDCouplingFieldDouble(ON_CELLS,ONE_TIME) ; f.setMesh(m)
f.setName("Field")
arr=DataArrayDouble(25,2) ; arr.setInfoOnComponents(compos)
- arr[:,0]=range(25)
- arr[:,1]=range(100,125)
+ arr[:,0]=list(range(25))
+ arr[:,1]=list(range(100,125))
f.setArray(arr)
WriteField(fileName,f,True)
f=MEDCouplingFieldDouble(ON_NODES,ONE_TIME) ; f.setMesh(m)
f.setName("FieldNode")
arr=DataArrayDouble(36,2) ; arr.setInfoOnComponents(compos)
- arr[:,0]=range(200,236)
- arr[:,1]=range(300,336)
+ arr[:,0]=list(range(200,236))
+ arr[:,1]=list(range(300,336))
f.setArray(arr)
f.checkConsistencyLight()
WriteFieldUsingAlreadyWrittenMesh(fileName,f)
fs=MEDFileFields.LoadPartOf(fileName,False,ms)
fs=fs.deepCopy()
fs[0][0].loadArrays()
- arr=DataArrayDouble(12,2) ; arr[:,0]=range(3,15) ; arr[:,1]=range(103,115)
+ arr = DataArrayDouble(12, 2) ; arr[:, 0] = list(range(3, 15)) ; arr[:, 1] = list(range(103, 115))
arr.setInfoOnComponents(compos)
self.assertTrue(fs[0][0].getUndergroundDataArray().isEqual(arr,1e-12))
fs[1][0].loadArrays()
- arr=DataArrayDouble(21,2) ; arr[:,0]=range(203,224) ; arr[:,1]=range(303,324)
+ arr = DataArrayDouble(21, 2) ; arr[:, 0] = list(range(203, 224)) ; arr[:, 1] = list(range(303, 324))
arr.setInfoOnComponents(compos)
self.assertTrue(fs[1][0].getUndergroundDataArray().isEqual(arr,1e-12))
pass
f=MEDCouplingFieldDouble(ON_CELLS,ONE_TIME) ; f.setMesh(m)
f.setName("Field")
arr=DataArrayDouble(25,2) ; arr.setInfoOnComponents(compos)
- arr[:,0]=range(25)
- arr[:,1]=range(100,125)
+ arr[:,0]=list(range(25))
+ arr[:,1]=list(range(100,125))
f.setArray(arr)
WriteField(fileName,f,True)
f=MEDCouplingFieldDouble(ON_NODES,ONE_TIME) ; f.setMesh(m)
f.setName("FieldNode")
arr=DataArrayDouble(36,2) ; arr.setInfoOnComponents(compos)
- arr[:,0]=range(200,236)
- arr[:,1]=range(300,336)
+ arr[:,0]=list(range(200,236))
+ arr[:,1]=list(range(300,336))
f.setArray(arr)
f.checkConsistencyLight()
WriteFieldUsingAlreadyWrittenMesh(fileName,f)
@unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
def testMEDFileUMeshPickeling1(self):
- import cPickle
outFileName="Pyfile86.med"
c=DataArrayDouble([-0.3,-0.3, 0.2,-0.3, 0.7,-0.3, -0.3,0.2, 0.2,0.2, 0.7,0.2, -0.3,0.7, 0.2,0.7, 0.7,0.7 ],9,2)
c.setInfoOnComponents(["aa","bbb"])
g2_1.setName("G2")
mm.setGroupsAtLevel(-1,[g1_1,g2_1],False)
g1_N=DataArrayInt.New()
- g1_N.setValues(range(8),8,1)
+ g1_N.setValues(list(range(8)),8,1)
g1_N.setName("G1")
g2_N=DataArrayInt.New()
- g2_N.setValues(range(9),9,1)
+ g2_N.setValues(list(range(9)),9,1)
g2_N.setName("G2")
mm.setGroupsAtLevel(1,[g1_N,g2_N],False)
mm.createGroupOnAll(0,"GrpOnAllCell")
self.assertTrue(mm.existsGroup("GrpOnAllCell"));
t=mm.getGroupArr(0,"GrpOnAllCell")
#
- st=cPickle.dumps(mm,cPickle.HIGHEST_PROTOCOL)
- mm2=cPickle.loads(st)
+ st=pickle.dumps(mm,pickle.HIGHEST_PROTOCOL)
+ mm2=pickle.loads(st)
self.assertTrue(mm.isEqual(mm2,1e-12)[0])
self.assertEqual(mm.getAxisType(),AX_CART)
#
mm.setAxisType(AX_CYL)
- st=cPickle.dumps(mm,cPickle.HIGHEST_PROTOCOL)
- mm2=cPickle.loads(st)
+ st=pickle.dumps(mm,pickle.HIGHEST_PROTOCOL)
+ mm2=pickle.loads(st)
self.assertTrue(mm.isEqual(mm2,1e-12)[0])
self.assertEqual(mm2.getAxisType(),AX_CYL)
pass
m.setName(meshName)
#
fmts=MEDFileFieldMultiTS()
- for i in xrange(nbPdt):
+ for i in range(nbPdt):
f=MEDCouplingFieldDouble(ON_NODES)
f.setMesh(m)
arr=DataArrayDouble(nbNodes) ; arr.iota() ; arr*=i
fs2=MEDFileFields.LoadSpecificEntities(fileName,[(ON_NODES,NORM_ERROR)],False)
fs.loadArraysIfNecessary()
fs2.loadArraysIfNecessary()
- for i in xrange(nbPdt):
+ for i in range(nbPdt):
self.assertTrue(fs[fieldName][i].getUndergroundDataArray().isEqual(fs2[fieldName][i].getUndergroundDataArray(),1e-12))
pass
m1=MEDCouplingCMesh() ; m1.setCoords(DataArrayDouble([0,1,2,3]),DataArrayDouble([0,1])) ; m1=m1.buildUnstructured() ; m1.simplexize(0)
m2=MEDCouplingCMesh() ; m2.setCoords(DataArrayDouble([3,4,5]),DataArrayDouble([0,1])) ; m2=m2.buildUnstructured()
m3=MEDCouplingUMesh.MergeUMeshes(m1,m2) ; m3.setName(meshName)
fmts=MEDFileFieldMultiTS()
- for i in xrange(nbPdt):
+ for i in range(nbPdt):
f=MEDCouplingFieldDouble(ON_CELLS)
f.setMesh(m3)
arr=DataArrayDouble(8) ; arr.iota() ; arr*=i
fs2.loadArraysIfNecessary()
fs3.loadArraysIfNecessary()
fs4.loadArraysIfNecessary()
- for i in xrange(nbPdt):
+ for i in range(nbPdt):
self.assertTrue(fs[fieldName][i].getUndergroundDataArray()[:6].isEqual(fs2[fieldName][i].getUndergroundDataArray(),1e-12))
self.assertTrue(fs[fieldName][i].getUndergroundDataArray()[6:8].isEqual(fs3[i].getUndergroundDataArray(),1e-12))
self.assertTrue(fs[fieldName][i].getUndergroundDataArray().isEqual(fs4[fieldName][i].getUndergroundDataArray(),1e-12))
m=m.buildUnstructured()
m.setName(meshName)
#
- nbOfField=nbPdt/maxPdt
+ nbOfField=nbPdt//maxPdt
fs=MEDFileFields()
- for j in xrange(nbOfField):
+ for j in range(nbOfField):
fmts=MEDFileFieldMultiTS()
s=DataArray.GetSlice(slice(0,nbPdt,1),j,nbOfField)
- for i in xrange(s.start,s.stop,s.step):
+ for i in range(s.start, s.stop, s.step):
f=MEDCouplingFieldDouble(ON_NODES)
f.setMesh(m)
arr=DataArrayDouble(nbNodes) ; arr.iota() ; arr*=i
fmts2.reverse()
zeResu=fmts2.pop()
nbIter=len(fmts2)
- for ii in xrange(nbIter):
+ for ii in range(nbIter):
zeResu.pushBackTimeSteps(fmts2.pop())
pass
zeResu.setName(k)
fs2.pushField(zeResu)
pass
- self.assertEqual(fs2[0].getTimeSteps(),[(i,0,float(i)) for i in xrange(nbPdt)])
+ self.assertEqual(fs2[0].getTimeSteps(), [(i, 0, float(i)) for i in range(nbPdt)])
pass
def testMEDFileMeshRearrangeFamIds1(self):
def __del__(self):
import os,sys
sys.stderr=self.origPyVal
+ if sys.version_info.major >= 3:
+ self.fdOfSinkFile.close()
+ pass
#os.fsync(self.fdOfSinkFile)
os.fsync(2)
os.dup2(self.stdoutOld,2)
mm.setName("mesh")
mm.write(fname,2)
# third : change permissions to remove write access on created file
- os.chmod(fname,0444)
+ os.chmod(fname, 0o444)
# four : try to append data on file -> check that it raises Exception
f=MEDCouplingFieldDouble(ON_CELLS)
f.setName("field")
mm=MEDFileCMesh(fname)
self.assertTrue(mm.getUnivName()!="")
pass
-
+
def testEmptyMesh(self):
""" MEDLoader should be able to consistently write and read an empty mesh (coords array
with 0 tuples """
grp2=bary1.findIdsInRange(0.-1e-12,0.+1e-12) ; grp2.setName(grpName2)
mesh.setGroupsAtLevel(-1,[grp1,grp2])
- import cPickle
- st=cPickle.dumps(mesh,2)
- mm=cPickle.loads(st)
- st2=cPickle.dumps(mm,2)
- mm2=cPickle.loads(st2)
+ st=pickle.dumps(mesh,2)
+ mm=pickle.loads(st)
+ st2=pickle.dumps(mm,2)
+ mm2=pickle.loads(st2)
self.assertTrue(mesh.isEqual(mm2,1e-12)[0])
pass
m1=MEDCouplingUMesh(m0.getName(),1)
m1.allocateCells(9)
conn1=[0,1,0,3,3,4,4,1,5,4,2,4,1,2,3,6,5,8]
- for i in xrange(9):
+ for i in range(9):
m1.insertNextCell(NORM_SEG2,conn1[2*i:2*i+2])
pass
m1.finishInsertingCells()
ff =mfd.getFields()[0][0].field(mfd.getMeshes()[0])
self.assertTrue(ff2.isEqual(ff,1e-12,1e-12))
# OK now end of joke -> serialization of MEDFileData
- import cPickle
- st=cPickle.dumps(mfd,cPickle.HIGHEST_PROTOCOL)
- mfd3=cPickle.loads(st)
+ st=pickle.dumps(mfd,pickle.HIGHEST_PROTOCOL)
+ mfd3=pickle.loads(st)
# check of object
self.assertEqual(len(mfd3.getMeshes()),1)
self.assertEqual(len(mfd3.getFields()),1)
ff3=mfd3.getFields()[0][0].field(mfd3.getMeshes()[0])
self.assertTrue(ff3.isEqual(ff,1e-12,1e-12))
# serialization of MEDFileFields
- st=cPickle.dumps(mfd.getFields(),cPickle.HIGHEST_PROTOCOL)
- fs4=cPickle.loads(st)
+ st=pickle.dumps(mfd.getFields(),pickle.HIGHEST_PROTOCOL)
+ fs4=pickle.loads(st)
ff4=fs4[0][0].field(mfd3.getMeshes()[0])
self.assertTrue(ff4.isEqual(ff,1e-12,1e-12))
# serialization of MEDFileFieldMulitTS
- st=cPickle.dumps(mfd.getFields()[0],cPickle.HIGHEST_PROTOCOL)
- fmts5=cPickle.loads(st)
+ st=pickle.dumps(mfd.getFields()[0],pickle.HIGHEST_PROTOCOL)
+ fmts5=pickle.loads(st)
ff5=fmts5[0].field(mfd3.getMeshes()[0])
self.assertTrue(ff5.isEqual(ff,1e-12,1e-12))
# serialization of MEDFileField1TS
- st=cPickle.dumps(mfd.getFields()[0][0],cPickle.HIGHEST_PROTOCOL)
- f1ts6=cPickle.loads(st)
+ st=pickle.dumps(mfd.getFields()[0][0],pickle.HIGHEST_PROTOCOL)
+ f1ts6=pickle.loads(st)
ff6=f1ts6.field(mfd3.getMeshes()[0])
self.assertTrue(ff6.isEqual(ff,1e-12,1e-12))
# serialization of MEDFileMeshes
- st=cPickle.dumps(mfd.getMeshes(),cPickle.HIGHEST_PROTOCOL)
- ms7=cPickle.loads(st)
+ st=pickle.dumps(mfd.getMeshes(),pickle.HIGHEST_PROTOCOL)
+ ms7=pickle.loads(st)
self.assertEqual(len(ms7),1)
self.assertTrue(ms7[0].isEqual(mfd.getMeshes()[0],1e-12))
pass
self.testMEDMesh6() # generates MEDFileMesh5.med file
mm=MEDFileMesh.New("MEDFileMesh5.med")
self.assertTrue(isinstance(mm,MEDFileCMesh))
- import cPickle
- st=cPickle.dumps(mm,cPickle.HIGHEST_PROTOCOL)
- mm2=cPickle.loads(st)
+ st=pickle.dumps(mm,pickle.HIGHEST_PROTOCOL)
+ mm2=pickle.loads(st)
self.assertTrue(isinstance(mm2,MEDFileCMesh))
self.assertTrue(mm.getMesh().isEqual(mm2.getMesh(),1e-12))
# CurveLinear
self.testCurveLinearMesh1() # generates Pyfile55.med
mm=MEDFileMesh.New("Pyfile55.med")
self.assertTrue(isinstance(mm,MEDFileCurveLinearMesh))
- st=cPickle.dumps(mm,cPickle.HIGHEST_PROTOCOL)
- mm3=cPickle.loads(st)
+ st=pickle.dumps(mm,pickle.HIGHEST_PROTOCOL)
+ mm3=pickle.loads(st)
self.assertTrue(isinstance(mm3,MEDFileCurveLinearMesh))
self.assertTrue(mm.getMesh().isEqual(mm3.getMesh(),1e-12))
self.testInt32InMEDFileFieldStar1()# generates Pyfile63.med
fs4=MEDFileFields("Pyfile63.med")
ms4=MEDFileMeshes("Pyfile63.med")
self.assertTrue(isinstance(fs4[0],MEDFileIntFieldMultiTS))
- st=cPickle.dumps(fs4[0],cPickle.HIGHEST_PROTOCOL)
- fmts5=cPickle.loads(st)
+ st=pickle.dumps(fs4[0],pickle.HIGHEST_PROTOCOL)
+ fmts5=pickle.loads(st)
self.assertEqual(len(fs4[0]),len(fmts5))
self.assertTrue(isinstance(fmts5,MEDFileIntFieldMultiTS))
self.assertTrue(fmts5[0].field(ms4[0]).isEqual((fs4[0][0]).field(ms4[0]),1e-12,1e-12))
# MEDFileIntField1TS
- st=cPickle.dumps(fs4[0][0],cPickle.HIGHEST_PROTOCOL)
- f1ts6=cPickle.loads(st)
+ st=pickle.dumps(fs4[0][0],pickle.HIGHEST_PROTOCOL)
+ f1ts6=pickle.loads(st)
self.assertTrue(isinstance(f1ts6,MEDFileIntField1TS))
self.assertTrue(f1ts6.field(ms4[0]).isEqual((fs4[0][0]).field(ms4[0]),1e-12,1e-12))
# MEDFileParameters
self.testParameters1()# generates Pyfile56.med
params=MEDFileParameters("Pyfile56.med")
- st=cPickle.dumps(params,cPickle.HIGHEST_PROTOCOL)
- params7=cPickle.loads(st)
+ st=pickle.dumps(params,pickle.HIGHEST_PROTOCOL)
+ params7=pickle.loads(st)
self.assertEqual(len(params),len(params7))
- for i in xrange(len(params)):
+ for i in range(len(params)):
self.assertTrue(params[i].isEqual(params7[i],1e-12)[0])
pass
pass
+
+ def testGlobalNumOnNodes1(self):
+ """Test global number on nodes here. Used by partitionners."""
+ fname="Pyfile112.med"
+ arr=DataArrayDouble(5) ; arr.iota()
+ m=MEDCouplingUMesh.Build1DMeshFromCoords(arr)
+ m.setName("mesh")
+ mm=MEDFileUMesh()
+ mm[0]=m
+ self.assertTrue(not mm.getGlobalNumFieldAtLevel(1))
+ d=DataArrayInt([7,8,9,2,0])
+ dRef=d.deepCopy()
+ mm.setGlobalNumFieldAtLevel(1,d)
+ mm.checkConsistency()
+ self.assertRaises(InterpKernelException,mm.setGlobalNumFieldAtLevel,1,d[::2])
+ mm.checkConsistency()
+ self.assertEqual(d.getHiddenCppPointer(),mm.getGlobalNumFieldAtLevel(1).getHiddenCppPointer())
+ self.assertTrue(mm.getGlobalNumFieldAtLevel(1).isEqual(dRef))
+ mm.write(fname,2)
+ mm2=MEDFileMesh.New(fname)
+ self.assertTrue(mm.isEqual(mm2,1e-12)[0])
+ self.assertTrue(mm2.getGlobalNumFieldAtLevel(1).isEqual(dRef))
+ mm2.getGlobalNumFieldAtLevel(1).setIJ(0,0,10)
+ self.assertTrue(not mm.isEqual(mm2,1e-12)[0])
+ mm2.getGlobalNumFieldAtLevel(1).setIJ(0,0,7)
+ self.assertTrue(mm.isEqual(mm2,1e-12)[0])
+ pass
+
+ def testPartialReadOfEntities1(self):
+ """Test for advanced API on read to speed up read phase for users with "huge" number of time steps (more than 10 000)."""
+ fname="Pyfile113.med"
+ arr=DataArrayDouble(5) ; arr.iota()
+ m=MEDCouplingUMesh.Build1DMeshFromCoords(arr)
+ m.setName("mesh")
+ mm=MEDFileUMesh()
+ mm[0]=m
+ #
+ fieldName="Field"
+ ts1=(5.,1,2)
+ f1=MEDCouplingFieldDouble(ON_NODES) ; f1.setMesh(m) ; f1.setName(fieldName)
+ f1.setArray(DataArrayDouble([0.,0.1,0.2,0.3,0.4]))
+ f1.setTime(*ts1)
+ f2=MEDCouplingFieldDouble(ON_CELLS) ; f2.setMesh(m) ; f2.setName(fieldName)
+ f2.setArray(DataArrayDouble([1.,1.1,1.2,1.3]))
+ f2.setTime(*ts1)
+ f1ts=MEDFileField1TS()
+ f1ts.setFieldNoProfileSBT(f1)
+ f1ts.setFieldNoProfileSBT(f2)
+ self.assertEqual(set(f1ts.getTypesOfFieldAvailable()),set([ON_NODES,ON_CELLS]))
+ f1ts_2=f1ts.deepCopy()
+ f1ts_2.getUndergroundDataArray()[:]+=2
+ f1ts_2.setTime(3,4,6.)
+ fmts=MEDFileFieldMultiTS()
+ fmts.pushBackTimeStep(f1ts)
+ fmts.pushBackTimeStep(f1ts_2)
+ #
+ mm.write(fname,2)
+ fmts.write(fname,0)
+ #
+ ent=MEDFileEntities.BuildFrom([(ON_NODES,NORM_ERROR)])
+ mm=MEDFileMesh.New(fname)
+ fs=MEDFileFields(fname,False,ent) # the important line is here - We specify to MEDFileFields to read only nodes part to speed up read phase (by avoiding to scan all entities time geo types)
+ fs.loadArrays()
+ self.assertEqual(len(fs),1)
+ fmts=fs[0]
+ self.assertEqual(len(fmts),2)
+ ff0=fmts[0] ; ff1=fmts[1]
+ self.assertEqual(ff0.getTypesOfFieldAvailable(),[ON_NODES]) # only NODES have been loaded
+ self.assertTrue(ff0.field(mm).isEqual(f1,1e-12,1e-12))
+ f3=f1.deepCopy() ; f3+=2. ; f3.setTime(6.,3,4)
+ self.assertTrue(ff1.field(mm).isEqual(f3,1e-12,1e-12))
+ pass
pass