X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FMEDCoupling%2FMEDCouplingUMesh_internal.cxx;h=4acfeb5601cd7c7c3f6a835da791c3d8df95d523;hb=0ba3453939dda0697b09ed7e728a01d4f33e3ce2;hp=c918cb650ee19903b208d93631361a24de6da503;hpb=ffb8188e28b2b60ee207a8644286821bc4e8fcdc;p=tools%2Fmedcoupling.git diff --git a/src/MEDCoupling/MEDCouplingUMesh_internal.cxx b/src/MEDCoupling/MEDCouplingUMesh_internal.cxx index c918cb650..4acfeb560 100755 --- a/src/MEDCoupling/MEDCouplingUMesh_internal.cxx +++ b/src/MEDCoupling/MEDCouplingUMesh_internal.cxx @@ -1,4 +1,4 @@ -// Copyright (C) 2007-2020 CEA/DEN, EDF R&D +// Copyright (C) 2007-2023 CEA, EDF // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public @@ -510,6 +510,11 @@ void MEDCouplingUMesh::fillCellIdsToKeepFromNodeIds(const mcIdType *begin, const MCAuto cellIdsKept=DataArrayIdType::New(); cellIdsKept->alloc(0,1); checkConnectivityFullyDefined(); mcIdType tmp=-1; + if(getNodalConnectivity()->empty()) + { + cellIdsKeptArr=cellIdsKept.retn(); + return; + } mcIdType sz=getNodalConnectivity()->getMaxValue(tmp); sz=std::max(sz,ToIdType(0))+1; std::vector fastFinder(sz,false); for(const mcIdType *work=begin;work!=end;work++) @@ -542,7 +547,7 @@ void MEDCouplingUMesh::fillCellIdsToKeepFromNodeIds(const mcIdType *begin, const * This method has one in/out parameter : 'cut3DCurve'. * Param 'cut3DCurve' is expected to be of size 'this->getNumberOfCells()'. For each i in [0,'this->getNumberOfCells()') * if cut3DCurve[i]==-2, it means that for cell #i in \a this nothing has been detected previously. - * if cut3DCurve[i]==-1, it means that cell#i has been already detected to be fully part of plane defined by ('origin','vec'). + * if cut3DCurve[i]==-1, it means that cell#i has been already detected to be fully (or partially) part of plane defined by ('origin','vec'). * This method will throw an exception if \a this contains a non linear segment. */ void MEDCouplingUMesh::split3DCurveWithPlane(const double *origin, const double *vec, double eps, std::vector& cut3DCurve) @@ -801,7 +806,7 @@ MEDCouplingUMesh *MEDCouplingUMesh::buildExtrudedMeshFromThisLowLev(mcIdType nbO for(mcIdType iz=0;iz(),newConnIPtr[iz*nbOf2DCells])); + std::transform(newConnIPtr+1,newConnIPtr+1+nbOf2DCells,newConnIPtr+1+iz*nbOf2DCells,std::bind(std::plus(),std::placeholders::_1,newConnIPtr[iz*nbOf2DCells])); const mcIdType *posOfTypeOfCell(newConnIPtr); for(std::vector::const_iterator iter=newc.begin();iter!=newc.end();iter++,newConnPtr++) { @@ -1308,6 +1313,74 @@ DataArrayIdType *MEDCouplingUMesh::buildUnionOf2DMeshQuadratic(const MEDCoupling return ret.retn(); } +/*! + * \param [in] arrIn array part of the indexed array pair to be treated + * \param [in] arrIndxIn array index part of the indexed array pair to be treated + * \param [out] arrOut array part of the indexed array pair containing result + * \param [out] arrIndxOut array index part of the indexed array pair containing result + */ +void MEDCouplingUMesh::DeleteCellTypeInIndexedArray(const DataArrayIdType *arrIn, const DataArrayIdType *arrIndxIn, MCAuto& arrOut, MCAuto& arrIndxOut) +{ + if( !arrIn || !arrIn->isAllocated() ) + THROW_IK_EXCEPTION("input array is null or not allocated !"); + if( !arrIndxIn || !arrIndxIn->isAllocated() ) + THROW_IK_EXCEPTION("input indexed array is null or not allocated !"); + arrIn->checkNbOfComps(1,"input array"); arrIndxIn->checkNbOfComps(1,"input indexed array"); + mcIdType arrNbTuples(arrIn->getNumberOfTuples()),arrIndxNbTuples(arrIndxIn->getNumberOfTuples()); + if( arrIndxNbTuples < 1 ) + THROW_IK_EXCEPTION("Indexed array is supposed to have length >= 1 !"); + if( arrNbTuples < arrIndxNbTuples ) + THROW_IK_EXCEPTION("Number of tuples of input array is to low compared to indexed array one !"); + const mcIdType *inArrPtr(arrIn->begin()),*inArrIndxPtr(arrIndxIn->begin()); + if( *inArrIndxPtr != 0 ) + THROW_IK_EXCEPTION("First value of indexed array must be 0 !"); + arrOut = DataArrayIdType::New(); arrOut->alloc(arrNbTuples-arrIndxNbTuples+1,1); + arrIndxOut = DataArrayIdType::New(); arrIndxOut->alloc(arrIndxNbTuples,1); + bool presenceOfPolyh = false; + { + mcIdType *outArrPtr(arrOut->getPointer()),*outArrIndxPtr(arrIndxOut->getPointer()); + *outArrIndxPtr++ = 0; + for( mcIdType i = 0 ; i < arrIndxNbTuples - 1 ; ++i ) + { + mcIdType startPos(*inArrIndxPtr++); + mcIdType endPos(*inArrIndxPtr); + if(inArrPtr[startPos] == INTERP_KERNEL::NORM_POLYHED) + { + presenceOfPolyh = true; + break; + } + outArrPtr = std::copy(inArrPtr+startPos+1,inArrPtr+endPos,outArrPtr); + *outArrIndxPtr++ = endPos - i - 1; + } + } + if(!presenceOfPolyh) + return ; + // + { + arrOut = DataArrayIdType::New(); arrOut->alloc(0,1); + inArrIndxPtr = arrIndxIn->begin(); + mcIdType *outArrIndxPtr = arrIndxOut->getPointer(); + *outArrIndxPtr++ = 0; + for( mcIdType i = 0 ; i < arrIndxNbTuples - 1 ; ++i,++outArrIndxPtr ) + { + mcIdType startPos(*inArrIndxPtr++); + mcIdType endPos(*inArrIndxPtr); + if(inArrPtr[startPos] != INTERP_KERNEL::NORM_POLYHED) + { + arrOut->insertAtTheEnd(inArrPtr+startPos+1,inArrPtr+endPos); + outArrIndxPtr[0] = outArrIndxPtr[-1] + (endPos-startPos-1); + } + else + { + std::set s(inArrPtr+startPos+1,inArrPtr+endPos); + s.erase( -1 ); + arrOut->insertAtTheEnd(s.begin(),s.end()); + outArrIndxPtr[0] = outArrIndxPtr[-1] + s.size(); + } + } + } +} + MEDCouplingUMesh *MEDCouplingUMesh::MergeUMeshesLL(const std::vector& a) { if(a.empty()) @@ -1342,7 +1415,7 @@ MEDCouplingUMesh *MEDCouplingUMesh::MergeUMeshesLL(const std::vectorgetNumberOfCells()); const mcIdType *curCI=(*it)->_nodal_connec_index->begin(); const mcIdType *curC=(*it)->_nodal_connec->begin(); - cIPtr=std::transform(curCI+1,curCI+curNbOfCell+1,cIPtr,std::bind2nd(std::plus(),offset)); + cIPtr=std::transform(curCI+1,curCI+curNbOfCell+1,cIPtr,std::bind(std::plus(),std::placeholders::_1,offset)); for(mcIdType j=0;j rConnBg(connEnd); std::reverse_iterator rConnEnd(connBg+1); - std::transform(rConnBg,rConnEnd,ii,std::bind2nd(std::plus(),deltaz)); + std::transform(rConnBg,rConnEnd,ii,std::bind(std::plus(),std::placeholders::_1,deltaz)); std::size_t nbOfRadFaces=std::distance(connBg+1,connEnd); for(std::size_t i=0;i3DCurve to deduce the intersection of each 3D surf cells * with a plane. The result will be put in 'cut3DSuf' out parameter. * \param [in] cut3DCurve input parameter that gives for each 3DCurve cell if it owns fully to the plane or partially. - * \param [out] nodesOnPlane, returns all the nodes that are on the plane. + * \param [out] nodesOnPlane returns all the nodes that are on the plane. * \param [in] nodal3DSurf is the nodal connectivity of 3D surf mesh. * \param [in] nodalIndx3DSurf is the nodal connectivity index of 3D surf mesh. * \param [in] nodal3DCurve is the nodal connectivity of 3D curve mesh. - * \param [in] nodal3DIndxCurve is the nodal connectivity index of 3D curve mesh. + * \param [in] nodalIndx3DCurve is the nodal connectivity index of 3D curve mesh. * \param [in] desc is the descending connectivity 3DSurf->3DCurve * \param [in] descIndx is the descending connectivity index 3DSurf->3DCurve - * \param [out] cut3DSuf input/output param. + * \param [out] cut3DSurf input/output param. */ void MEDCouplingUMesh::AssemblyForSplitFrom3DCurve(const std::vector& cut3DCurve, std::vector& nodesOnPlane, const mcIdType *nodal3DSurf, const mcIdType *nodalIndx3DSurf, const mcIdType *nodal3DCurve, const mcIdType *nodalIndx3DCurve, @@ -1619,11 +1692,20 @@ void MEDCouplingUMesh::AssemblyForSplitFrom3DCurve(const std::vector& res.push_back(status); else { - res.push_back(nodal3DCurve[nodalIndx3DCurve[edgeId]+1]); - res.push_back(nodal3DCurve[nodalIndx3DCurve[edgeId]+2]); + const mcIdType& node1 = nodal3DCurve[nodalIndx3DCurve[edgeId]+1]; + const mcIdType& node2 = nodal3DCurve[nodalIndx3DCurve[edgeId]+2]; + // Here, we have an edge that has either one or both of its nodes intersecting the plane + // we're only adding the nodes from the edges fully contained in the plane + if(std::find(nodesOnP.begin(), nodesOnP.end(),node1) != nodesOnP.end() + && std::find(nodesOnP.begin(), nodesOnP.end(),node2) != nodesOnP.end()) + { + res.push_back(node1); + res.push_back(node2); + } } } } + switch(res.size()) { case 2: @@ -1818,7 +1900,7 @@ void MEDCouplingUMesh::attractSeg3MidPtsAroundNodesUnderground(double ratio, con auto ptToMove(nc[*nci+3]); auto attractor(aa?nc[*nci+1]:nc[*nci+2]),endPt(aa?nc[*nci+2]:nc[*nci+1]); std::transform(coords+spaceDim*attractor,coords+spaceDim*(attractor+1),coords+spaceDim*endPt, - coords+spaceDim*ptToMove,[ratio](const double& stPt, const double& endPt) { return stPt+ratio*(endPt-stPt); }); + coords+spaceDim*ptToMove,[ratio](const double& stPt2, const double& endPt2) { return stPt2+ratio*(endPt2-stPt2); }); } else continue;//both 2 boundary nodes of current seg3 are un nodeIds input list -> skip it.