X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FINTERP_KERNEL%2FSplitterTetra.txx;h=ce0136d99360f1b9c708b70eadd3b703e77ac738;hb=b219559763498c4bd10c730cd3d2c62b1eed45db;hp=0cb18c057644164d1a7ec29d530f950958ddc270;hpb=2ca1698844b207f817bf98f0fdea13478de9a0db;p=tools%2Fmedcoupling.git diff --git a/src/INTERP_KERNEL/SplitterTetra.txx b/src/INTERP_KERNEL/SplitterTetra.txx index 0cb18c057..ce0136d99 100644 --- a/src/INTERP_KERNEL/SplitterTetra.txx +++ b/src/INTERP_KERNEL/SplitterTetra.txx @@ -1,9 +1,9 @@ -// Copyright (C) 2007-2013 CEA/DEN, EDF R&D +// Copyright (C) 2007-2019 CEA/DEN, EDF R&D // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either -// version 2.1 of the License. +// version 2.1 of the License, or (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -99,7 +99,7 @@ namespace INTERP_KERNEL * \param [in] tetraCorners array 4*3 doubles containing corners of input tetrahedron (P0X,P0Y,P0Y,P1X,P1Y,P1Z,P2X,P2Y,P2Z,P3X,P3Y,P3Z). */ template - SplitterTetra::SplitterTetra(const MyMeshType& srcMesh, const double tetraCorners[12], const int *conn): _t(0),_src_mesh(srcMesh) + SplitterTetra::SplitterTetra(const MyMeshType& srcMesh, const double tetraCorners[12], const ConnType *conn): _t(0),_src_mesh(srcMesh) { if(!conn) { _conn[0]=0; _conn[1]=1; _conn[2]=2; _conn[3]=3; } @@ -121,7 +121,7 @@ namespace INTERP_KERNEL SplitterTetra::~SplitterTetra() { delete _t; - for(HashMap< int, double* >::iterator iter = _nodes.begin(); iter != _nodes.end() ; ++iter) + for(typename HashMap< ConnType, double* >::iterator iter = _nodes.begin(); iter != _nodes.end() ; ++iter) delete[] iter->second; } @@ -191,17 +191,17 @@ namespace INTERP_KERNEL // get type of cell NormalizedCellType normCellType=_src_mesh.getTypeOfElement(OTT::indFC(element)); const CellModel& cellModelCell=CellModel::GetCellModel(normCellType); - unsigned nbOfNodes4Type=cellModelCell.isDynamic() ? _src_mesh.getNumberOfNodesOfElement(OTT::indFC(element)) : cellModelCell.getNumberOfNodes(); + ConnType nbOfNodes4Type=cellModelCell.isDynamic() ? _src_mesh.getNumberOfNodesOfElement(OTT::indFC(element)) : cellModelCell.getNumberOfNodes(); // halfspace filtering bool isOutside[8] = {true, true, true, true, true, true, true, true}; bool isTargetOutside = false; // calculate the coordinates of the nodes - int *cellNodes=new int[nbOfNodes4Type]; - for(int i = 0;i<(int)nbOfNodes4Type;++i) + ConnType *cellNodes=new ConnType[nbOfNodes4Type]; + for(ConnType i = 0;i global numbers too, but not sure it is worth it - const int globalNodeNum = getGlobalNumberOfNode(i, OTT::indFC(element), _src_mesh); + const ConnType globalNodeNum = getGlobalNumberOfNode(i, OTT::indFC(element), _src_mesh); cellNodes[i]=globalNodeNum; if(_nodes.find(globalNodeNum) == _nodes.end()) { @@ -232,19 +232,19 @@ namespace INTERP_KERNEL // get nb of sons of a cell const ConnType* rawCellConn = _src_mesh.getConnectivityPtr() + OTT::conn2C( _src_mesh.getConnectivityIndexPtr()[ element ]); - const int rawNbCellNodes = _src_mesh.getConnectivityIndexPtr()[ element+1 ] - _src_mesh.getConnectivityIndexPtr()[ element ]; + const ConnType rawNbCellNodes = _src_mesh.getConnectivityIndexPtr()[ element+1 ] - _src_mesh.getConnectivityIndexPtr()[ element ]; unsigned nbOfSons = cellModelCell.getNumberOfSons2(rawCellConn, rawNbCellNodes); for(unsigned ii = 0 ; ii < nbOfSons; ++ii) { // get sons connectivity NormalizedCellType faceType; - int *faceNodes, nbFaceNodes=-1; + ConnType *faceNodes, nbFaceNodes=-1; if ( cellModelCell.isDynamic() ) { - faceNodes=new int[nbOfNodes4Type]; + faceNodes=new ConnType[nbOfNodes4Type]; nbFaceNodes = cellModelCell.fillSonCellNodalConnectivity2(ii,rawCellConn,rawNbCellNodes,faceNodes,faceType); - for ( int i = 0; i < nbFaceNodes; ++i ) + for ( ConnType i = 0; i < nbFaceNodes; ++i ) faceNodes[i] = OTT::coo2C(faceNodes[i]); } else @@ -252,7 +252,8 @@ namespace INTERP_KERNEL faceType = cellModelCell.getSonType(ii); const CellModel& faceModel=CellModel::GetCellModel(faceType); assert(faceModel.getDimension() == 2); - faceNodes=new int[faceModel.getNumberOfNodes()]; + nbFaceNodes = cellModelCell.getNumberOfNodesConstituentTheSon(ii); + faceNodes = new ConnType[nbFaceNodes]; cellModelCell.fillSonCellNodalConnectivity(ii,cellNodes,faceNodes); } // intersect a son with the unit tetra @@ -325,8 +326,8 @@ namespace INTERP_KERNEL case NORM_POLYGON: { - int nbTria = nbFaceNodes - 2; // split polygon into nbTria triangles - for ( int iTri = 0; iTri < nbTria; ++iTri ) + ConnType nbTria = nbFaceNodes - 2; // split polygon into nbTria triangles + for ( ConnType iTri = 0; iTri < nbTria; ++iTri ) { TriangleFaceKey key = TriangleFaceKey(faceNodes[0], faceNodes[1+iTri], faceNodes[2+iTri]); if(_volumes.find(key) == _volumes.end()) @@ -393,7 +394,6 @@ namespace INTERP_KERNEL { typedef typename MyMeshType::MyConnType ConnType; typedef double Vect2[2]; - typedef double Vect3[3]; typedef double Triangle2[3][2]; const double *const tri0[3] = {p1, p2, p3}; @@ -589,16 +589,14 @@ namespace INTERP_KERNEL */ template double SplitterTetra::intersectSourceFace(const NormalizedCellType polyType, - const int polyNodesNbr, - const int *const polyNodes, + const ConnType polyNodesNbr, + const ConnType *const polyNodes, const double *const *const polyCoords, const double dimCaracteristic, const double precision, std::multiset& listOfTetraFacesTreated, std::set& listOfTetraFacesColinear) { - typedef typename MyMeshType::MyConnType ConnType; - double totalSurface = 0.0; // check if we have planar tetra element @@ -616,9 +614,9 @@ namespace INTERP_KERNEL bool isTargetOutside = false; // calculate the coordinates of the nodes - for(int i = 0;i<(int)polyNodesNbr;++i) + for(ConnType i = 0;i::releaseArrays() { // free potential sub-mesh nodes that have been allocated - typename MyMeshTypeT::MyConnType nbOfNodesT = _node_ids.size();// Issue 0020634. - if((int)_nodes.size()>=/*8*/nbOfNodesT) + if(_nodes.size()>=/*8*/_node_ids.size()) { + typename MyMeshTypeT::MyConnType nbOfNodesT = static_cast(_node_ids.size()); std::vector::iterator iter = _nodes.begin() + /*8*/nbOfNodesT; while(iter != _nodes.end()) { @@ -931,21 +929,22 @@ namespace INTERP_KERNEL template void SplitterTetra2::splitTargetCell2(typename MyMeshTypeT::MyConnType targetCell, typename std::vector< SplitterTetra* >& tetra) { - const int *refConn(_target_mesh.getConnectivityPtr()); - const int *cellConn(refConn+_target_mesh.getConnectivityIndexPtr()[targetCell]); + typedef typename MyMeshTypeT::MyConnType TConnType; + const TConnType *refConn(_target_mesh.getConnectivityPtr()); + const TConnType *cellConn(refConn+_target_mesh.getConnectivityIndexPtr()[targetCell]); INTERP_KERNEL::NormalizedCellType gt(_target_mesh.getTypeOfElement(targetCell)); - std::vector tetrasNodalConn; + std::vector tetrasNodalConn; std::vector addCoords; const double *coords(_target_mesh.getCoordinatesPtr()); SplitIntoTetras(_splitting_pol,gt,cellConn,refConn+_target_mesh.getConnectivityIndexPtr()[targetCell+1],coords,tetrasNodalConn,addCoords); std::size_t nbTetras(tetrasNodalConn.size()/4); tetra.resize(nbTetras); double tmp[12]; - int tmp2[4]; + typename MyMeshTypeS::MyConnType tmp2[4]; for(std::size_t i=0;i=0) { @@ -982,7 +981,7 @@ namespace INTERP_KERNEL _node_ids.resize(8); tetra.reserve(1); const double *nodes[4]; - int conn[4]; + ConnType conn[4]; for(int node = 0; node < 4 ; ++node) { nodes[node]=getCoordsOfNode2(node, OTT::indFC(targetCell),_target_mesh,conn[node]); @@ -1063,7 +1062,7 @@ namespace INTERP_KERNEL for(int i = 0; i < 5; ++i) { const double* nodes[4]; - int conn[4]; + typename MyMeshTypeS::MyConnType conn[4]; for(int j = 0; j < 4; ++j) { conn[j] = subZone[ SPLIT_NODES_5[4*i+j] ]; @@ -1087,7 +1086,7 @@ namespace INTERP_KERNEL for(int i = 0; i < 6; ++i) { const double* nodes[4]; - int conn[4]; + typename MyMeshTypeS::MyConnType conn[4]; for(int j = 0; j < 4; ++j) { conn[j] = subZone[SPLIT_NODES_6[4*i+j]]; @@ -1110,11 +1109,11 @@ namespace INTERP_KERNEL { // The two nodes of the original mesh cell used in each tetrahedron. // The tetrahedra all have nodes (cellCenter, faceCenter, edgeNode1, edgeNode2) - // For the correspondance of the nodes, see the GENERAL_48_SUB_NODES table in calculateSubNodes + // For the correspondence of the nodes, see the GENERAL_48_SUB_NODES table in calculateSubNodes // nodes to use for tetrahedron const double* nodes[4]; - int conn[4]; + typename MyMeshTypeS::MyConnType conn[4]; // get the cell center conn[0] = 14; nodes[0] = getCoordsOfSubNode(conn[0]); @@ -1174,7 +1173,7 @@ namespace INTERP_KERNEL // create tetrahedra const double* nodes[4]; - int conn[4]; + typename MyMeshTypeS::MyConnType conn[4]; for(int i = 0; i < 2; ++i) { for(int j = 0; j < 4; ++j) @@ -1200,22 +1199,24 @@ namespace INTERP_KERNEL // get type of cell and nb of cell nodes NormalizedCellType normCellType=_target_mesh.getTypeOfElement(OTT::indFC(targetCell)); const CellModel& cellModelCell=CellModel::GetCellModel(normCellType); - unsigned nbOfCellNodes=cellModelCell.isDynamic() ? _target_mesh.getNumberOfNodesOfElement(OTT::indFC(targetCell)) : cellModelCell.getNumberOfNodes(); + ConnType nbOfCellNodes=cellModelCell.isDynamic() ? _target_mesh.getNumberOfNodesOfElement(OTT::indFC(targetCell)) : cellModelCell.getNumberOfNodes(); // get nb of cell sons (faces) const ConnType* rawCellConn = _target_mesh.getConnectivityPtr() + OTT::conn2C( _target_mesh.getConnectivityIndexPtr()[ targetCell ]); - const int rawNbCellNodes = _target_mesh.getConnectivityIndexPtr()[ targetCell+1 ] - _target_mesh.getConnectivityIndexPtr()[ targetCell ]; + const ConnType rawNbCellNodes = _target_mesh.getConnectivityIndexPtr()[ targetCell+1 ] - _target_mesh.getConnectivityIndexPtr()[ targetCell ]; unsigned nbOfSons = cellModelCell.getNumberOfSons2(rawCellConn, rawNbCellNodes); // indices of nodes of a son - static std::vector allNodeIndices; // == 0,1,2,...,nbOfCellNodes-1 - while ( allNodeIndices.size() < nbOfCellNodes ) - allNodeIndices.push_back( allNodeIndices.size() ); - std::vector classicFaceNodes(4); - int* faceNodes = cellModelCell.isDynamic() ? &allNodeIndices[0] : &classicFaceNodes[0]; + static std::vector allNodeIndices; // == 0,1,2,...,nbOfCellNodes-1 + while ( allNodeIndices.size() < (std::size_t)nbOfCellNodes ) + allNodeIndices.push_back( static_cast(allNodeIndices.size()) ); + std::vector classicFaceNodes(4); + if(cellModelCell.isQuadratic()) + throw INTERP_KERNEL::Exception("SplitterTetra2::splitConvex : quadratic 3D cells are not implemented yet !"); + ConnType* faceNodes = cellModelCell.isDynamic() ? &allNodeIndices[0] : &classicFaceNodes[0]; // nodes of tetrahedron - int conn[4]; + typename MyMeshTypeS::MyConnType conn[4]; const double* nodes[4]; nodes[3] = getCoordsOfSubNode2( nbOfCellNodes,conn[3]); // barycenter @@ -1260,7 +1261,7 @@ namespace INTERP_KERNEL { // retrieve real mesh nodes - typename MyMeshTypeT::MyConnType nbOfNodesT = _node_ids.size();// Issue 0020634. _node_ids.resize(8); + typename MyMeshTypeT::MyConnType nbOfNodesT = static_cast(_node_ids.size());// Issue 0020634. _node_ids.resize(8); for(int node = 0; node < nbOfNodesT ; ++node) { // calculate only normal nodes