X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FMEDCoupling%2FMEDCoupling1GTUMesh.cxx;h=63cd815fd0876f0a8d4cd957f65a797f736c1984;hb=84031c1872103b9a0c9546ea12c4ebd03838034d;hp=193b34f2fac44a4789f240039801c6a0c9bfbff2;hpb=5e1db0c2532041e4f0b1d6533db612438041fbaa;p=tools%2Fmedcoupling.git diff --git a/src/MEDCoupling/MEDCoupling1GTUMesh.cxx b/src/MEDCoupling/MEDCoupling1GTUMesh.cxx index 193b34f2f..63cd815fd 100644 --- a/src/MEDCoupling/MEDCoupling1GTUMesh.cxx +++ b/src/MEDCoupling/MEDCoupling1GTUMesh.cxx @@ -1,9 +1,9 @@ -// Copyright (C) 2007-2013 CEA/DEN, EDF R&D +// Copyright (C) 2007-2020 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 @@ -16,17 +16,27 @@ // // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // -// Author : Anthony Geay (CEA/DEN) +// Author : Anthony Geay (EDF R&D) -#include "MEDCoupling1GTUMesh.hxx" +#include "MEDCoupling1GTUMesh.txx" #include "MEDCouplingUMesh.hxx" #include "MEDCouplingFieldDouble.hxx" +#include "MEDCouplingCMesh.hxx" #include "SplitterTetra.hxx" +#include "DiameterCalculator.hxx" +#include "OrientationInverter.hxx" +#include "InterpKernelAutoPtr.hxx" -using namespace ParaMEDMEM; +using namespace MEDCoupling; -MEDCoupling1GTUMesh::MEDCoupling1GTUMesh(const char *name, const INTERP_KERNEL::CellModel& cm):_cm(&cm) +const int MEDCoupling1SGTUMesh::HEXA8_FACE_PAIRS[6]={0,1,2,4,3,5}; + +MEDCoupling1GTUMesh::MEDCoupling1GTUMesh():_cm(0) +{ +} + +MEDCoupling1GTUMesh::MEDCoupling1GTUMesh(const std::string& name, const INTERP_KERNEL::CellModel& cm):_cm(&cm) { setName(name); } @@ -35,7 +45,7 @@ MEDCoupling1GTUMesh::MEDCoupling1GTUMesh(const MEDCoupling1GTUMesh& other, bool { } -MEDCoupling1GTUMesh *MEDCoupling1GTUMesh::New(const char *name, INTERP_KERNEL::NormalizedCellType type) throw(INTERP_KERNEL::Exception) +MEDCoupling1GTUMesh *MEDCoupling1GTUMesh::New(const std::string& name, INTERP_KERNEL::NormalizedCellType type) { if(type==INTERP_KERNEL::NORM_ERROR) throw INTERP_KERNEL::Exception("MEDCoupling1GTUMesh::New : NORM_ERROR is not a valid type to be used as base geometric type for a mesh !"); @@ -46,7 +56,7 @@ MEDCoupling1GTUMesh *MEDCoupling1GTUMesh::New(const char *name, INTERP_KERNEL::N return MEDCoupling1DGTUMesh::New(name,type); } -MEDCoupling1GTUMesh *MEDCoupling1GTUMesh::New(const MEDCouplingUMesh *m) throw(INTERP_KERNEL::Exception) +MEDCoupling1GTUMesh *MEDCoupling1GTUMesh::New(const MEDCouplingUMesh *m) { if(!m) throw INTERP_KERNEL::Exception("MEDCoupling1GTUMesh::New : input mesh is null !"); @@ -60,12 +70,12 @@ MEDCoupling1GTUMesh *MEDCoupling1GTUMesh::New(const MEDCouplingUMesh *m) throw(I return MEDCoupling1DGTUMesh::New(m); } -const INTERP_KERNEL::CellModel& MEDCoupling1GTUMesh::getCellModel() const throw(INTERP_KERNEL::Exception) +const INTERP_KERNEL::CellModel& MEDCoupling1GTUMesh::getCellModel() const { return *_cm; } -INTERP_KERNEL::NormalizedCellType MEDCoupling1GTUMesh::getCellModelEnum() const throw(INTERP_KERNEL::Exception) +INTERP_KERNEL::NormalizedCellType MEDCoupling1GTUMesh::getCellModelEnum() const { return _cm->getEnum(); } @@ -84,9 +94,9 @@ int MEDCoupling1GTUMesh::getMeshDimension() const * \param [in] type the geometric type * \return cell ids in this having geometric type \a type. */ -DataArrayInt *MEDCoupling1GTUMesh::giveCellsWithType(INTERP_KERNEL::NormalizedCellType type) const throw(INTERP_KERNEL::Exception) +DataArrayIdType *MEDCoupling1GTUMesh::giveCellsWithType(INTERP_KERNEL::NormalizedCellType type) const { - MEDCouplingAutoRefCountObjectPtr ret=DataArrayInt::New(); + MCAuto ret=DataArrayIdType::New(); if(type==getCellModelEnum()) ret->alloc(getNumberOfCells(),1); else @@ -98,7 +108,7 @@ DataArrayInt *MEDCoupling1GTUMesh::giveCellsWithType(INTERP_KERNEL::NormalizedCe /*! * Returns nb of cells having the geometric type \a type. No throw if no cells in \a this has the geometric type \a type. */ -int MEDCoupling1GTUMesh::getNumberOfCellsWithType(INTERP_KERNEL::NormalizedCellType type) const +mcIdType MEDCoupling1GTUMesh::getNumberOfCellsWithType(INTERP_KERNEL::NormalizedCellType type) const { return type==getCellModelEnum()?getNumberOfCells():0; } @@ -109,9 +119,9 @@ int MEDCoupling1GTUMesh::getNumberOfCellsWithType(INTERP_KERNEL::NormalizedCellT * \return INTERP_KERNEL::NormalizedCellType - enumeration item describing the cell type. * \throw If \a cellId is invalid. Valid range is [0, \a this->getNumberOfCells() ). */ -INTERP_KERNEL::NormalizedCellType MEDCoupling1GTUMesh::getTypeOfCell(int cellId) const +INTERP_KERNEL::NormalizedCellType MEDCoupling1GTUMesh::getTypeOfCell(mcIdType cellId) const { - if(cellId>=0 && cellId MEDCoupling1GTUMesh::getAllGeoTypes( * \a this is composed in cell types. * The returned array is of size 3*n where n is the number of different types present in \a this. * For every k in [0,n] ret[3*k+2]==-1 because it has no sense here. - * This parameter is kept only for compatibility with other methode listed above. + * This parameter is kept only for compatibility with other method listed above. */ -std::vector MEDCoupling1GTUMesh::getDistributionOfTypes() const throw(INTERP_KERNEL::Exception) +std::vector MEDCoupling1GTUMesh::getDistributionOfTypes() const { - std::vector ret(3); - ret[0]=(int)getCellModelEnum(); ret[1]=getNumberOfCells(); ret[2]=-1; + std::vector ret(3); + ret[0]=ToIdType(getCellModelEnum()); ret[1]=getNumberOfCells(); ret[2]=-1; return ret; } @@ -168,29 +178,28 @@ std::vector MEDCoupling1GTUMesh::getDistributionOfTypes() const throw(INTER * - After \a code contains [NORM_...,nbCells,0], \a idsInPflPerType [[0,1]] and \a idsPerType is [[1,2]]
*/ -void MEDCoupling1GTUMesh::splitProfilePerType(const DataArrayInt *profile, std::vector& code, std::vector& idsInPflPerType, std::vector& idsPerType) const throw(INTERP_KERNEL::Exception) +void MEDCoupling1GTUMesh::splitProfilePerType(const DataArrayIdType *profile, std::vector& code, std::vector& idsInPflPerType, std::vector& idsPerType, bool smartPflKiller) const { if(!profile) throw INTERP_KERNEL::Exception("MEDCoupling1GTUMesh::splitProfilePerType : input profile is NULL !"); if(profile->getNumberOfComponents()!=1) throw INTERP_KERNEL::Exception("MEDCoupling1GTUMesh::splitProfilePerType : input profile should have exactly one component !"); - int nbTuples=profile->getNumberOfTuples(); - int nbOfCells=getNumberOfCells(); + mcIdType nbTuples=profile->getNumberOfTuples(),nbOfCells=getNumberOfCells(); code.resize(3); idsInPflPerType.resize(1); - code[0]=(int)getCellModelEnum(); code[1]=nbTuples; + code[0]=ToIdType(getCellModelEnum()); code[1]=nbTuples; idsInPflPerType.resize(1); - if(profile->isIdentity() && nbTuples==nbOfCells) + if(smartPflKiller && profile->isIota(nbOfCells)) { code[2]=-1; - idsInPflPerType[0]=const_cast(profile); idsInPflPerType[0]->incrRef(); + idsInPflPerType[0]=const_cast(profile); idsInPflPerType[0]->incrRef(); idsPerType.clear(); return ; } code[2]=0; profile->checkAllIdsInRange(0,nbOfCells); idsPerType.resize(1); - idsPerType[0]=const_cast(profile); idsPerType[0]->incrRef(); - idsInPflPerType[0]=DataArrayInt::Range(0,nbTuples,1); + idsPerType[0]=const_cast(profile); idsPerType[0]->incrRef(); + idsInPflPerType[0]=DataArrayIdType::Range(0,nbTuples,1); } /*! @@ -199,12 +208,12 @@ void MEDCoupling1GTUMesh::splitProfilePerType(const DataArrayInt *profile, std:: * * \sa MEDCouplingUMesh::checkTypeConsistencyAndContig */ -DataArrayInt *MEDCoupling1GTUMesh::checkTypeConsistencyAndContig(const std::vector& code, const std::vector& idsPerType) const throw(INTERP_KERNEL::Exception) +DataArrayIdType *MEDCoupling1GTUMesh::checkTypeConsistencyAndContig(const std::vector& code, const std::vector& idsPerType) const { - int nbOfCells=getNumberOfCells(); + mcIdType nbOfCells=getNumberOfCells(); if(code.size()!=3) throw INTERP_KERNEL::Exception("MEDCoupling1GTUMesh::checkTypeConsistencyAndContig : invalid input code should be exactly of size 3 !"); - if(code[0]!=(int)getCellModelEnum()) + if(code[0]!=ToIdType(getCellModelEnum())) { std::ostringstream oss; oss << "MEDCoupling1GTUMesh::checkTypeConsistencyAndContig : Mismatch of geometric type ! Asking for " << code[0] << " whereas the geometric type is \a this is " << getCellModelEnum() << " (" << _cm->getRepr() << ") !"; throw INTERP_KERNEL::Exception(oss.str().c_str()); @@ -222,34 +231,39 @@ DataArrayInt *MEDCoupling1GTUMesh::checkTypeConsistencyAndContig(const std::vect if(code[2]!=0) throw INTERP_KERNEL::Exception("MEDCoupling1GTUMesh::checkTypeConsistencyAndContig : single geo type mesh ! 0 or -1 is expected at pos #2 of input code !"); if(idsPerType.size()!=1) - throw INTERP_KERNEL::Exception("MEDCoupling1GTUMesh::checkTypeConsistencyAndContig : input code points to DataArrayInt #0 whereas the size of idsPerType is not equal to 1 !"); - const DataArrayInt *pfl=idsPerType[0]; + throw INTERP_KERNEL::Exception("MEDCoupling1GTUMesh::checkTypeConsistencyAndContig : input code points to DataArrayIdType #0 whereas the size of idsPerType is not equal to 1 !"); + const DataArrayIdType *pfl=idsPerType[0]; if(!pfl) - throw INTERP_KERNEL::Exception("MEDCoupling1GTUMesh::checkTypeConsistencyAndContig : the input code points to a NULL DataArrayInt at rank 0 !"); + throw INTERP_KERNEL::Exception("MEDCoupling1GTUMesh::checkTypeConsistencyAndContig : the input code points to a NULL DataArrayIdType at rank 0 !"); if(pfl->getNumberOfComponents()!=1) throw INTERP_KERNEL::Exception("MEDCoupling1GTUMesh::checkTypeConsistencyAndContig : input profile should have exactly one component !"); pfl->checkAllIdsInRange(0,nbOfCells); pfl->incrRef(); - return const_cast(pfl); + return const_cast(pfl); } -void MEDCoupling1GTUMesh::writeVTKLL(std::ostream& ofs, const std::string& cellData, const std::string& pointData) const throw(INTERP_KERNEL::Exception) +void MEDCoupling1GTUMesh::writeVTKLL(std::ostream& ofs, const std::string& cellData, const std::string& pointData, DataArrayByte *byteData) const { - MEDCouplingAutoRefCountObjectPtr m=buildUnstructured(); - m->writeVTKLL(ofs,cellData,pointData); + MCAuto m=buildUnstructured(); + m->writeVTKLL(ofs,cellData,pointData,byteData); } -std::string MEDCoupling1GTUMesh::getVTKDataSetType() const throw(INTERP_KERNEL::Exception) +std::string MEDCoupling1GTUMesh::getVTKDataSetType() const { return std::string("UnstructuredGrid"); } -std::size_t MEDCoupling1GTUMesh::getHeapMemorySize() const +std::string MEDCoupling1GTUMesh::getVTKFileExtension() const { - return MEDCouplingPointSet::getHeapMemorySize(); + return std::string("vtu"); } -bool MEDCoupling1GTUMesh::isEqualIfNotWhy(const MEDCouplingMesh *other, double prec, std::string& reason) const throw(INTERP_KERNEL::Exception) +std::size_t MEDCoupling1GTUMesh::getHeapMemorySizeWithoutChildren() const +{ + return MEDCouplingPointSet::getHeapMemorySizeWithoutChildren(); +} + +bool MEDCoupling1GTUMesh::isEqualIfNotWhy(const MEDCouplingMesh *other, double prec, std::string& reason) const { if(!MEDCouplingPointSet::isEqualIfNotWhy(other,prec,reason)) return false; @@ -283,30 +297,30 @@ bool MEDCoupling1GTUMesh::isEqualWithoutConsideringStr(const MEDCouplingMesh *ot return true; } -void MEDCoupling1GTUMesh::checkCoherency() const throw(INTERP_KERNEL::Exception) +void MEDCoupling1GTUMesh::checkConsistencyLight() const { - MEDCouplingPointSet::checkCoherency(); + MEDCouplingPointSet::checkConsistencyLight(); } -DataArrayDouble *MEDCoupling1GTUMesh::getBarycenterAndOwner() const +DataArrayDouble *MEDCoupling1GTUMesh::computeCellCenterOfMass() const { - MEDCouplingAutoRefCountObjectPtr m=buildUnstructured(); - MEDCouplingAutoRefCountObjectPtr ret=m->getBarycenterAndOwner(); + MCAuto m=buildUnstructured(); + MCAuto ret=m->computeCellCenterOfMass(); return ret.retn(); } MEDCouplingFieldDouble *MEDCoupling1GTUMesh::getMeasureField(bool isAbs) const { - MEDCouplingAutoRefCountObjectPtr m=buildUnstructured(); - MEDCouplingAutoRefCountObjectPtr ret=m->getMeasureField(isAbs); + MCAuto m=buildUnstructured(); + MCAuto ret=m->getMeasureField(isAbs); ret->setMesh(this); return ret.retn(); } MEDCouplingFieldDouble *MEDCoupling1GTUMesh::getMeasureFieldOnNode(bool isAbs) const { - MEDCouplingAutoRefCountObjectPtr m=buildUnstructured(); - MEDCouplingAutoRefCountObjectPtr ret=m->getMeasureFieldOnNode(isAbs); + MCAuto m=buildUnstructured(); + MCAuto ret=m->getMeasureFieldOnNode(isAbs); ret->setMesh(this); return ret.retn(); } @@ -314,59 +328,68 @@ MEDCouplingFieldDouble *MEDCoupling1GTUMesh::getMeasureFieldOnNode(bool isAbs) c /*! * to improve perf ! */ -int MEDCoupling1GTUMesh::getCellContainingPoint(const double *pos, double eps) const +mcIdType MEDCoupling1GTUMesh::getCellContainingPoint(const double *pos, double eps) const { - MEDCouplingAutoRefCountObjectPtr m=buildUnstructured(); + MCAuto m(buildUnstructured()); return m->getCellContainingPoint(pos,eps); } +/*! + * to improve perf ! + */ +void MEDCoupling1GTUMesh::getCellsContainingPoint(const double *pos, double eps, std::vector& elts) const +{ + MCAuto m(buildUnstructured()); + return m->getCellsContainingPoint(pos,eps,elts); +} + MEDCouplingFieldDouble *MEDCoupling1GTUMesh::buildOrthogonalField() const { - MEDCouplingAutoRefCountObjectPtr m=buildUnstructured(); - MEDCouplingAutoRefCountObjectPtr ret=m->buildOrthogonalField(); + MCAuto m=buildUnstructured(); + MCAuto ret=m->buildOrthogonalField(); ret->setMesh(this); return ret.retn(); } -DataArrayInt *MEDCoupling1GTUMesh::getCellsInBoundingBox(const double *bbox, double eps) const +DataArrayIdType *MEDCoupling1GTUMesh::getCellsInBoundingBox(const double *bbox, double eps) const { - MEDCouplingAutoRefCountObjectPtr m=buildUnstructured(); + MCAuto m=buildUnstructured(); return m->getCellsInBoundingBox(bbox,eps); } -DataArrayInt *MEDCoupling1GTUMesh::getCellsInBoundingBox(const INTERP_KERNEL::DirectedBoundingBox& bbox, double eps) +DataArrayIdType *MEDCoupling1GTUMesh::getCellsInBoundingBox(const INTERP_KERNEL::DirectedBoundingBox& bbox, double eps) { - MEDCouplingAutoRefCountObjectPtr m=buildUnstructured(); + MCAuto m=buildUnstructured(); return m->getCellsInBoundingBox(bbox,eps); } -MEDCouplingPointSet *MEDCoupling1GTUMesh::buildFacePartOfMySelfNode(const int *start, const int *end, bool fullyIn) const +MEDCouplingPointSet *MEDCoupling1GTUMesh::buildFacePartOfMySelfNode(const mcIdType *start, const mcIdType *end, bool fullyIn) const { - MEDCouplingAutoRefCountObjectPtr m=buildUnstructured(); + MCAuto m=buildUnstructured(); return m->buildFacePartOfMySelfNode(start,end,fullyIn); } -DataArrayInt *MEDCoupling1GTUMesh::findBoundaryNodes() const +DataArrayIdType *MEDCoupling1GTUMesh::findBoundaryNodes() const { - MEDCouplingAutoRefCountObjectPtr m=buildUnstructured(); + MCAuto m=buildUnstructured(); return m->findBoundaryNodes(); } MEDCouplingPointSet *MEDCoupling1GTUMesh::buildBoundaryMesh(bool keepCoords) const { - MEDCouplingAutoRefCountObjectPtr m=buildUnstructured(); + MCAuto m=buildUnstructured(); return m->buildBoundaryMesh(keepCoords); } -void MEDCoupling1GTUMesh::findCommonCells(int compType, int startCellId, DataArrayInt *& commonCellsArr, DataArrayInt *& commonCellsIArr) const throw(INTERP_KERNEL::Exception) +void MEDCoupling1GTUMesh::findCommonCells(int compType, mcIdType startCellId, DataArrayIdType *& commonCellsArr, DataArrayIdType *& commonCellsIArr) const { - MEDCouplingAutoRefCountObjectPtr m=buildUnstructured(); + MCAuto m=buildUnstructured(); m->findCommonCells(compType,startCellId,commonCellsArr,commonCellsIArr); } -int MEDCoupling1GTUMesh::getNodalConnectivityLength() const throw(INTERP_KERNEL::Exception) +mcIdType MEDCoupling1GTUMesh::getNodalConnectivityLength() const { - const DataArrayInt *c1(getNodalConnectivity()); + const DataArrayIdType *c1(getNodalConnectivity()); if(!c1) throw INTERP_KERNEL::Exception("MEDCoupling1GTUMesh::getNodalConnectivityLength : no connectivity set !"); if(c1->getNumberOfComponents()!=1) @@ -389,7 +412,7 @@ int MEDCoupling1GTUMesh::getNodalConnectivityLength() const throw(INTERP_KERNEL: * \throw If not all the parts have their connectivity set properly. * \throw If \a parts is empty. */ -MEDCouplingUMesh *MEDCoupling1GTUMesh::AggregateOnSameCoordsToUMesh(const std::vector< const MEDCoupling1GTUMesh *>& parts) throw(INTERP_KERNEL::Exception) +MEDCouplingUMesh *MEDCoupling1GTUMesh::AggregateOnSameCoordsToUMesh(const std::vector< const MEDCoupling1GTUMesh *>& parts) { if(parts.empty()) throw INTERP_KERNEL::Exception("MEDCoupling1GTUMesh::AggregateOnSameCoordsToUMesh : input parts vector is empty !"); @@ -398,9 +421,9 @@ MEDCouplingUMesh *MEDCoupling1GTUMesh::AggregateOnSameCoordsToUMesh(const std::v throw INTERP_KERNEL::Exception("MEDCoupling1GTUMesh::AggregateOnSameCoordsToUMesh : the first instance in input parts is null !"); const DataArrayDouble *coords(firstPart->getCoords()); int meshDim(firstPart->getMeshDimension()); - MEDCouplingAutoRefCountObjectPtr ret(MEDCouplingUMesh::New(firstPart->getName().c_str(),meshDim)); ret->setDescription(firstPart->getDescription().c_str()); + MCAuto ret(MEDCouplingUMesh::New(firstPart->getName(),meshDim)); ret->setDescription(firstPart->getDescription()); ret->setCoords(coords); - int nbOfCells(0),connSize(0); + mcIdType nbOfCells(0),connSize(0); for(std::vector< const MEDCoupling1GTUMesh *>::const_iterator it=parts.begin();it!=parts.end();it++) { if(!(*it)) @@ -412,19 +435,19 @@ MEDCouplingUMesh *MEDCoupling1GTUMesh::AggregateOnSameCoordsToUMesh(const std::v nbOfCells+=(*it)->getNumberOfCells(); connSize+=(*it)->getNodalConnectivityLength(); } - MEDCouplingAutoRefCountObjectPtr conn(DataArrayInt::New()),connI(DataArrayInt::New()); + MCAuto conn(DataArrayIdType::New()),connI(DataArrayIdType::New()); connI->alloc(nbOfCells+1,1); conn->alloc(connSize+nbOfCells,1); - int *c(conn->getPointer()),*ci(connI->getPointer()); *ci=0; + mcIdType *c(conn->getPointer()),*ci(connI->getPointer()); *ci=0; for(std::vector< const MEDCoupling1GTUMesh *>::const_iterator it=parts.begin();it!=parts.end();it++) { - int curNbCells((*it)->getNumberOfCells()); - int geoType((int)(*it)->getCellModelEnum()); - const int *cinPtr((*it)->getNodalConnectivity()->begin()); + mcIdType curNbCells=(*it)->getNumberOfCells(); + mcIdType geoType(ToIdType((*it)->getCellModelEnum())); + const mcIdType *cinPtr((*it)->getNodalConnectivity()->begin()); const MEDCoupling1SGTUMesh *ps(dynamic_cast(*it)); const MEDCoupling1DGTUMesh *pd(dynamic_cast(*it)); if(ps && !pd) { - int nNodesPerCell(ps->getNumberOfNodesPerCell()); + mcIdType nNodesPerCell(ps->getNumberOfNodesPerCell()); for(int i=0;igetNodalConnectivityIndex()->begin()); + const mcIdType *ciinPtr(pd->getNodalConnectivityIndex()->begin()); for(int i=0;ideepCpy(); + _conn=c->deepCopy(); } } -MEDCoupling1SGTUMesh::MEDCoupling1SGTUMesh(const char *name, const INTERP_KERNEL::CellModel& cm):MEDCoupling1GTUMesh(name,cm) +MEDCoupling1SGTUMesh::MEDCoupling1SGTUMesh(const std::string& name, const INTERP_KERNEL::CellModel& cm):MEDCoupling1GTUMesh(name,cm) +{ +} + +MEDCoupling1SGTUMesh::MEDCoupling1SGTUMesh() { } -MEDCoupling1SGTUMesh *MEDCoupling1SGTUMesh::New(const char *name, INTERP_KERNEL::NormalizedCellType type) throw(INTERP_KERNEL::Exception) +MEDCoupling1SGTUMesh *MEDCoupling1SGTUMesh::New() +{ + return new MEDCoupling1SGTUMesh; +} + +MEDCoupling1SGTUMesh *MEDCoupling1SGTUMesh::New(const std::string& name, INTERP_KERNEL::NormalizedCellType type) { if(type==INTERP_KERNEL::NORM_ERROR) throw INTERP_KERNEL::Exception("MEDCoupling1SGTUMesh::New : NORM_ERROR is not a valid type to be used as base geometric type for a mesh !"); @@ -478,22 +510,22 @@ MEDCoupling1SGTUMesh *MEDCoupling1SGTUMesh::New(const char *name, INTERP_KERNEL: return new MEDCoupling1SGTUMesh(name,cm); } -MEDCoupling1SGTUMesh *MEDCoupling1SGTUMesh::New(const MEDCouplingUMesh *m) throw(INTERP_KERNEL::Exception) +MEDCoupling1SGTUMesh *MEDCoupling1SGTUMesh::New(const MEDCouplingUMesh *m) { if(!m) throw INTERP_KERNEL::Exception("MEDCoupling1SGTUMesh::New : input mesh is null !"); std::set gts(m->getAllGeoTypes()); if(gts.size()!=1) throw INTERP_KERNEL::Exception("MEDCoupling1SGTUMesh::New : input mesh must have exactly one geometric type !"); - int geoType((int)*gts.begin()); - MEDCouplingAutoRefCountObjectPtr ret(MEDCoupling1SGTUMesh::New(m->getName().c_str(),*gts.begin())); - ret->setCoords(m->getCoords()); ret->setDescription(m->getDescription().c_str()); - int nbCells(m->getNumberOfCells()); - int nbOfNodesPerCell(ret->getNumberOfNodesPerCell()); - MEDCouplingAutoRefCountObjectPtr conn(DataArrayInt::New()); conn->alloc(nbCells*nbOfNodesPerCell,1); - int *c(conn->getPointer()); - const int *cin(m->getNodalConnectivity()->begin()),*ciin(m->getNodalConnectivityIndex()->begin()); - for(int i=0;i ret(MEDCoupling1SGTUMesh::New(m->getName(),*gts.begin())); + ret->setCoords(m->getCoords()); ret->setDescription(m->getDescription()); + mcIdType nbCells=m->getNumberOfCells(); + mcIdType nbOfNodesPerCell(ret->getNumberOfNodesPerCell()); + MCAuto conn(DataArrayIdType::New()); conn->alloc(nbCells*nbOfNodesPerCell,1); + mcIdType *c(conn->getPointer()); + const mcIdType *cin(m->getNodalConnectivity()->begin()),*ciin(m->getNodalConnectivityIndex()->begin()); + for(mcIdType i=0;isetNodalConnectivity(conn); + try + { ret->copyTinyInfoFrom(m); } + catch(INTERP_KERNEL::Exception&) { } return ret.retn(); } @@ -521,22 +556,22 @@ MEDCoupling1SGTUMesh *MEDCoupling1SGTUMesh::clone(bool recDeepCpy) const } /*! - * This method behaves mostly like MEDCoupling1SGTUMesh::deepCpy method, except that only nodal connectivity arrays are deeply copied. + * This method behaves mostly like MEDCoupling1SGTUMesh::deepCopy method, except that only nodal connectivity arrays are deeply copied. * The coordinates are shared between \a this and the returned instance. * - * \return MEDCouplingUMesh * - A new object instance holding the copy of \a this (deep for connectivity, shallow for coordiantes) - * \sa MEDCoupling1SGTUMesh::deepCpy + * \return MEDCoupling1SGTUMesh * - A new object instance holding the copy of \a this (deep for connectivity, shallow for coordiantes) + * \sa MEDCoupling1SGTUMesh::deepCopy */ -MEDCouplingPointSet *MEDCoupling1SGTUMesh::deepCpyConnectivityOnly() const throw(INTERP_KERNEL::Exception) +MEDCoupling1SGTUMesh *MEDCoupling1SGTUMesh::deepCopyConnectivityOnly() const { - checkCoherency(); - MEDCouplingAutoRefCountObjectPtr ret(clone(false)); - MEDCouplingAutoRefCountObjectPtr c(_conn->deepCpy()); + checkConsistencyLight(); + MCAuto ret(clone(false)); + MCAuto c(_conn->deepCopy()); ret->setNodalConnectivity(c); return ret.retn(); } -void MEDCoupling1SGTUMesh::shallowCopyConnectivityFrom(const MEDCouplingPointSet *other) throw(INTERP_KERNEL::Exception) +void MEDCoupling1SGTUMesh::shallowCopyConnectivityFrom(const MEDCouplingPointSet *other) { if(!other) throw INTERP_KERNEL::Exception("MEDCoupling1SGTUMesh::shallowCopyConnectivityFrom : input pointer is null !"); @@ -549,26 +584,29 @@ void MEDCoupling1SGTUMesh::shallowCopyConnectivityFrom(const MEDCouplingPointSet void MEDCoupling1SGTUMesh::updateTime() const { MEDCoupling1GTUMesh::updateTime(); - const DataArrayInt *c(_conn); + const DataArrayIdType *c(_conn); if(c) updateTimeWith(*c); } -std::size_t MEDCoupling1SGTUMesh::getHeapMemorySize() const +std::size_t MEDCoupling1SGTUMesh::getHeapMemorySizeWithoutChildren() const { - std::size_t ret=0; - const DataArrayInt *c(_conn); - if(c) - ret+=c->getHeapMemorySize(); - return MEDCoupling1GTUMesh::getHeapMemorySize()+ret; + return MEDCoupling1GTUMesh::getHeapMemorySizeWithoutChildren(); +} + +std::vector MEDCoupling1SGTUMesh::getDirectChildrenWithNull() const +{ + std::vector ret(MEDCoupling1GTUMesh::getDirectChildrenWithNull()); + ret.push_back((const DataArrayIdType *)_conn); + return ret; } -MEDCouplingMesh *MEDCoupling1SGTUMesh::deepCpy() const +MEDCoupling1SGTUMesh *MEDCoupling1SGTUMesh::deepCopy() const { return clone(true); } -bool MEDCoupling1SGTUMesh::isEqualIfNotWhy(const MEDCouplingMesh *other, double prec, std::string& reason) const throw(INTERP_KERNEL::Exception) +bool MEDCoupling1SGTUMesh::isEqualIfNotWhy(const MEDCouplingMesh *other, double prec, std::string& reason) const { if(!other) throw INTERP_KERNEL::Exception("MEDCoupling1SGTUMesh::isEqualIfNotWhy : input other pointer is null !"); @@ -581,7 +619,7 @@ bool MEDCoupling1SGTUMesh::isEqualIfNotWhy(const MEDCouplingMesh *other, double } if(!MEDCoupling1GTUMesh::isEqualIfNotWhy(other,prec,reason)) return false; - const DataArrayInt *c1(_conn),*c2(otherC->_conn); + const DataArrayIdType *c1(_conn),*c2(otherC->_conn); if(c1==c2) return true; if(!c1 || !c2) @@ -591,7 +629,7 @@ bool MEDCoupling1SGTUMesh::isEqualIfNotWhy(const MEDCouplingMesh *other, double } if(!c1->isEqualIfNotWhy(*c2,reason)) { - reason.insert(0,"Nodal connectivity DataArrayInt differ : "); + reason.insert(0,"Nodal connectivity DataArrayIdType differ : "); return false; } return true; @@ -606,7 +644,7 @@ bool MEDCoupling1SGTUMesh::isEqualWithoutConsideringStr(const MEDCouplingMesh *o return false; if(!MEDCoupling1GTUMesh::isEqualWithoutConsideringStr(other,prec)) return false; - const DataArrayInt *c1(_conn),*c2(otherC->_conn); + const DataArrayIdType *c1(_conn),*c2(otherC->_conn); if(c1==c2) return true; if(!c1 || !c2) @@ -616,9 +654,9 @@ bool MEDCoupling1SGTUMesh::isEqualWithoutConsideringStr(const MEDCouplingMesh *o return true; } -void MEDCoupling1SGTUMesh::checkCoherencyOfConnectivity() const throw(INTERP_KERNEL::Exception) +void MEDCoupling1SGTUMesh::checkConsistencyOfConnectivity() const { - const DataArrayInt *c1(_conn); + const DataArrayIdType *c1(_conn); if(c1) { if(c1->getNumberOfComponents()!=1) @@ -631,27 +669,27 @@ void MEDCoupling1SGTUMesh::checkCoherencyOfConnectivity() const throw(INTERP_KER throw INTERP_KERNEL::Exception("Nodal connectivity array not defined !"); } -void MEDCoupling1SGTUMesh::checkCoherency() const throw(INTERP_KERNEL::Exception) +void MEDCoupling1SGTUMesh::checkConsistencyLight() const { - MEDCouplingPointSet::checkCoherency(); - checkCoherencyOfConnectivity(); + MEDCouplingPointSet::checkConsistencyLight(); + checkConsistencyOfConnectivity(); } -void MEDCoupling1SGTUMesh::checkCoherency1(double eps) const throw(INTERP_KERNEL::Exception) +void MEDCoupling1SGTUMesh::checkConsistency(double eps) const { - checkCoherency(); - const DataArrayInt *c1(_conn); - int nbOfTuples=c1->getNumberOfTuples(); - int nbOfNodesPerCell=(int)_cm->getNumberOfNodes(); + checkConsistencyLight(); + const DataArrayIdType *c1(_conn); + mcIdType nbOfTuples(c1->getNumberOfTuples()); + mcIdType nbOfNodesPerCell=_cm->getNumberOfNodes(); if(nbOfTuples%nbOfNodesPerCell!=0) { - std::ostringstream oss; oss << "MEDCoupling1SGTUMesh::checkCoherency1 : the nb of tuples in conn is " << nbOfTuples << " and number of nodes per cell is " << nbOfNodesPerCell << ". But " << nbOfTuples << "%" << nbOfNodesPerCell << " !=0 !"; + std::ostringstream oss; oss << "MEDCoupling1SGTUMesh::checkConsistency : the nb of tuples in conn is " << nbOfTuples << " and number of nodes per cell is " << nbOfNodesPerCell << ". But " << nbOfTuples << "%" << nbOfNodesPerCell << " !=0 !"; throw INTERP_KERNEL::Exception(oss.str().c_str()); } - int nbOfNodes=getNumberOfNodes(); - int nbOfCells=nbOfTuples/nbOfNodesPerCell; - const int *w(c1->begin()); - for(int i=0;ibegin()); + for(mcIdType i=0;i=nbOfNodes) @@ -662,15 +700,10 @@ void MEDCoupling1SGTUMesh::checkCoherency1(double eps) const throw(INTERP_KERNEL } } -void MEDCoupling1SGTUMesh::checkCoherency2(double eps) const throw(INTERP_KERNEL::Exception) -{ - checkCoherency1(eps); -} - -int MEDCoupling1SGTUMesh::getNumberOfCells() const +mcIdType MEDCoupling1SGTUMesh::getNumberOfCells() const { - int nbOfTuples=getNodalConnectivityLength(); - int nbOfNodesPerCell=getNumberOfNodesPerCell(); + mcIdType nbOfTuples(getNodalConnectivityLength()); + mcIdType nbOfNodesPerCell(getNumberOfNodesPerCell()); if(nbOfTuples%nbOfNodesPerCell!=0) { std::ostringstream oss; oss << "MEDCoupling1SGTUMesh:getNumberOfCells: : the nb of tuples in conn is " << nbOfTuples << " and number of nodes per cell is " << nbOfNodesPerCell << ". But " << nbOfTuples << "%" << nbOfNodesPerCell << " !=0 !"; @@ -679,52 +712,57 @@ int MEDCoupling1SGTUMesh::getNumberOfCells() const return nbOfTuples/nbOfNodesPerCell; } -int MEDCoupling1SGTUMesh::getNumberOfNodesPerCell() const throw(INTERP_KERNEL::Exception) +mcIdType MEDCoupling1SGTUMesh::getNumberOfNodesInCell(mcIdType cellId) const +{ + return getNumberOfNodesPerCell(); +} + +mcIdType MEDCoupling1SGTUMesh::getNumberOfNodesPerCell() const { checkNonDynamicGeoType(); - return (int)_cm->getNumberOfNodes(); + return _cm->getNumberOfNodes(); } -DataArrayInt *MEDCoupling1SGTUMesh::computeNbOfNodesPerCell() const throw(INTERP_KERNEL::Exception) +DataArrayIdType *MEDCoupling1SGTUMesh::computeNbOfNodesPerCell() const { checkNonDynamicGeoType(); - MEDCouplingAutoRefCountObjectPtr ret=DataArrayInt::New(); + MCAuto ret=DataArrayIdType::New(); ret->alloc(getNumberOfCells(),1); - ret->fillWithValue((int)_cm->getNumberOfNodes()); + ret->fillWithValue(_cm->getNumberOfNodes()); return ret.retn(); } -DataArrayInt *MEDCoupling1SGTUMesh::computeNbOfFacesPerCell() const throw(INTERP_KERNEL::Exception) +DataArrayIdType *MEDCoupling1SGTUMesh::computeNbOfFacesPerCell() const { checkNonDynamicGeoType(); - MEDCouplingAutoRefCountObjectPtr ret=DataArrayInt::New(); + MCAuto ret=DataArrayIdType::New(); ret->alloc(getNumberOfCells(),1); - ret->fillWithValue((int)_cm->getNumberOfSons()); + ret->fillWithValue(ToIdType(_cm->getNumberOfSons())); return ret.retn(); } -DataArrayInt *MEDCoupling1SGTUMesh::computeEffectiveNbOfNodesPerCell() const throw(INTERP_KERNEL::Exception) +DataArrayIdType *MEDCoupling1SGTUMesh::computeEffectiveNbOfNodesPerCell() const { checkNonDynamicGeoType(); - MEDCouplingAutoRefCountObjectPtr ret=DataArrayInt::New(); - int nbCells(getNumberOfCells()); + MCAuto ret=DataArrayIdType::New(); + mcIdType nbCells=getNumberOfCells(); ret->alloc(nbCells,1); - int *retPtr(ret->getPointer()); - int nbNodesPerCell(getNumberOfNodesPerCell()); - const int *conn(_conn->begin()); - for(int i=0;igetPointer()); + mcIdType nbNodesPerCell(getNumberOfNodesPerCell()); + const mcIdType *conn(_conn->begin()); + for(mcIdType i=0;i s(conn,conn+nbNodesPerCell); - *retPtr=(int)s.size(); + std::set s(conn,conn+nbNodesPerCell); + *retPtr=ToIdType(s.size()); } return ret.retn(); } -void MEDCoupling1SGTUMesh::getNodeIdsOfCell(int cellId, std::vector& conn) const +void MEDCoupling1SGTUMesh::getNodeIdsOfCell(mcIdType cellId, std::vector& conn) const { - int sz=getNumberOfNodesPerCell(); + mcIdType sz=getNumberOfNodesPerCell(); conn.resize(sz); - if(cellId>=0 && cellIdbegin()+cellId*sz,_conn->begin()+(cellId+1)*sz,conn.begin()); else { @@ -733,7 +771,7 @@ void MEDCoupling1SGTUMesh::getNodeIdsOfCell(int cellId, std::vector& conn) } } -void MEDCoupling1SGTUMesh::checkNonDynamicGeoType() const throw(INTERP_KERNEL::Exception) +void MEDCoupling1SGTUMesh::checkNonDynamicGeoType() const { if(_cm->isDynamic()) throw INTERP_KERNEL::Exception("MEDCoupling1SGTUMesh::checkNonDynamicGeoType : internal error ! the internal geo type is dynamic ! should be static !"); @@ -743,6 +781,11 @@ std::string MEDCoupling1SGTUMesh::simpleRepr() const { static const char msg0[]="No coordinates specified !"; std::ostringstream ret; + if(!_cm) + { + ret << "No geometric type specified" << std::endl; + return ret.str(); + } ret << "Single static geometic type (" << _cm->getRepr() << ") unstructured mesh with name : \"" << getName() << "\"\n"; ret << "Description of mesh : \"" << getDescription() << "\"\n"; int tmpp1,tmpp2; @@ -766,7 +809,7 @@ std::string MEDCoupling1SGTUMesh::simpleRepr() const else ret << msg0 << "\n"; ret << "Number of cells : "; - if((const DataArrayInt *)_conn) + if((const DataArrayIdType *)_conn) { if(_conn->isAllocated()) { @@ -795,21 +838,21 @@ std::string MEDCoupling1SGTUMesh::advancedRepr() const ret << "No array set !\n"; ret << "\n\nConnectivity array : \n____________________\n\n"; // - if((const DataArrayInt *)_conn) + if((const DataArrayIdType *)_conn) { if(_conn->isAllocated()) { if(_conn->getNumberOfComponents()==1) { - int nbOfCells=getNumberOfCells(); - int sz=getNumberOfNodesPerCell(); - const int *connPtr=_conn->begin(); - for(int i=0;i(ret," ")); - ret << "\n"; - } + mcIdType nbOfCells=getNumberOfCells(); + mcIdType sz=getNumberOfNodesPerCell(); + const mcIdType *connPtr=_conn->begin(); + for(mcIdType i=0;i(ret," ")); + ret << "\n"; + } } else ret << "Nodal connectivity array specified and allocated but with not exactly one component !" << "\n"; @@ -822,22 +865,22 @@ std::string MEDCoupling1SGTUMesh::advancedRepr() const return ret.str(); } -DataArrayDouble *MEDCoupling1SGTUMesh::computeIsoBarycenterOfNodesPerCell() const throw(INTERP_KERNEL::Exception) +DataArrayDouble *MEDCoupling1SGTUMesh::computeIsoBarycenterOfNodesPerCell() const { - MEDCouplingAutoRefCountObjectPtr ret=DataArrayDouble::New(); + MCAuto ret=DataArrayDouble::New(); int spaceDim=getSpaceDimension(); - int nbOfCells=getNumberOfCells();//checkCoherency() - int nbOfNodes=getNumberOfNodes(); + mcIdType nbOfCells=getNumberOfCells();//checkConsistencyLight() + mcIdType nbOfNodes=getNumberOfNodes(); ret->alloc(nbOfCells,spaceDim); double *ptToFill=ret->getPointer(); const double *coor=_coords->begin(); - const int *nodal=_conn->begin(); - int sz=getNumberOfNodesPerCell(); - double coeff=1./(double)sz; - for(int i=0;ibegin(); + mcIdType sz=getNumberOfNodesPerCell(); + double coeff=1./FromIdType(sz); + for(mcIdType i=0;i=0 && *nodal()); else @@ -845,31 +888,31 @@ DataArrayDouble *MEDCoupling1SGTUMesh::computeIsoBarycenterOfNodesPerCell() cons std::ostringstream oss; oss << "MEDCoupling1SGTUMesh::computeIsoBarycenterOfNodesPerCell : on cell #" << i << " presence of nodeId #" << *nodal << " should be in [0," << nbOfNodes << ") !"; throw INTERP_KERNEL::Exception(oss.str().c_str()); } - std::transform(ptToFill,ptToFill+spaceDim,ptToFill,std::bind2nd(std::multiplies(),coeff)); + std::transform(ptToFill,ptToFill+spaceDim,ptToFill,std::bind(std::multiplies(),std::placeholders::_1,coeff)); } return ret.retn(); } -void MEDCoupling1SGTUMesh::renumberCells(const int *old2NewBg, bool check) throw(INTERP_KERNEL::Exception) +void MEDCoupling1SGTUMesh::renumberCells(const mcIdType *old2NewBg, bool check) { - int nbCells=getNumberOfCells(); - MEDCouplingAutoRefCountObjectPtr o2n=DataArrayInt::New(); - o2n->useArray(old2NewBg,false,C_DEALLOC,nbCells,1); + mcIdType nbCells=getNumberOfCells(); + MCAuto o2n=DataArrayIdType::New(); + o2n->useArray(old2NewBg,false,DeallocType::C_DEALLOC,nbCells,1); if(check) o2n=o2n->checkAndPreparePermutation(); // - const int *conn=_conn->begin(); - MEDCouplingAutoRefCountObjectPtr n2o=o2n->invertArrayO2N2N2O(nbCells); - const int *n2oPtr=n2o->begin(); - MEDCouplingAutoRefCountObjectPtr newConn=DataArrayInt::New(); + const mcIdType *conn=_conn->begin(); + MCAuto n2o=o2n->invertArrayO2N2N2O(nbCells); + const mcIdType *n2oPtr=n2o->begin(); + MCAuto newConn=DataArrayIdType::New(); newConn->alloc(_conn->getNumberOfTuples(),1); newConn->copyStringInfoFrom(*_conn); - int sz=getNumberOfNodesPerCell(); + mcIdType sz=getNumberOfNodesPerCell(); // - int *newC=newConn->getPointer(); - for(int i=0;igetPointer(); + for(mcIdType i=0;i cellIdsKept=DataArrayInt::New(); cellIdsKept->alloc(0,1); - int tmp=-1; - int sz=_conn->getMaxValue(tmp); sz=std::max(sz,0)+1; + mcIdType nbOfCells=getNumberOfCells(); + MCAuto cellIdsKept=DataArrayIdType::New(); cellIdsKept->alloc(0,1); + mcIdType tmp=-1; + mcIdType sz=_conn->getMaxValue(tmp); sz=std::max(sz,ToIdType(0))+1; std::vector fastFinder(sz,false); - for(const int *work=begin;work!=end;work++) + for(const mcIdType *work=begin;work!=end;work++) if(*work>=0 && *workbegin(); - int nbNodesPerCell=getNumberOfNodesPerCell(); - for(int i=0;ibegin(); + mcIdType nbNodesPerCell=getNumberOfNodesPerCell(); + for(mcIdType i=0;i=0) { ref++; @@ -922,41 +965,44 @@ MEDCouplingMesh *MEDCoupling1SGTUMesh::mergeMyselfWith(const MEDCouplingMesh *ot return Merge1SGTUMeshes(this,otherC); } -MEDCouplingUMesh *MEDCoupling1SGTUMesh::buildUnstructured() const throw(INTERP_KERNEL::Exception) +MEDCouplingUMesh *MEDCoupling1SGTUMesh::buildUnstructured() const { - MEDCouplingAutoRefCountObjectPtr ret=MEDCouplingUMesh::New(getName().c_str(),getMeshDimension()); + MCAuto ret=MEDCouplingUMesh::New(getName(),getMeshDimension()); ret->setCoords(getCoords()); - const int *nodalConn=_conn->begin(); - int nbCells=getNumberOfCells(); - int nbNodesPerCell=getNumberOfNodesPerCell(); - int geoType=(int)getCellModelEnum(); - MEDCouplingAutoRefCountObjectPtr c=DataArrayInt::New(); c->alloc(nbCells*(nbNodesPerCell+1),1); - int *cPtr=c->getPointer(); - for(int i=0;ibegin(); + mcIdType nbCells=getNumberOfCells(); + mcIdType nbNodesPerCell=getNumberOfNodesPerCell(); + mcIdType geoType=ToIdType(getCellModelEnum()); + MCAuto c=DataArrayIdType::New(); c->alloc(nbCells*(nbNodesPerCell+1),1); + mcIdType *cPtr=c->getPointer(); + for(mcIdType i=0;i cI=DataArrayInt::Range(0,(nbCells+1)*(nbNodesPerCell+1),nbNodesPerCell+1); + MCAuto cI=DataArrayIdType::Range(0,(nbCells+1)*(nbNodesPerCell+1),nbNodesPerCell+1); ret->setConnectivity(c,cI,true); + try + { ret->copyTinyInfoFrom(this); } + catch(INTERP_KERNEL::Exception&) { } return ret.retn(); } -DataArrayInt *MEDCoupling1SGTUMesh::simplexize(int policy) throw(INTERP_KERNEL::Exception) +DataArrayIdType *MEDCoupling1SGTUMesh::simplexize(int policy) { switch(policy) - { + { case 0: return simplexizePol0(); case 1: return simplexizePol1(); - case (int) INTERP_KERNEL::PLANAR_FACE_5: - return simplexizePlanarFace5(); - case (int) INTERP_KERNEL::PLANAR_FACE_6: - return simplexizePlanarFace6(); + case INTERP_KERNEL::PLANAR_FACE_5: + return simplexizePlanarFace5(); + case INTERP_KERNEL::PLANAR_FACE_6: + return simplexizePlanarFace6(); default: throw INTERP_KERNEL::Exception("MEDCoupling1SGTUMesh::simplexize : unrecognized policy ! Must be :\n - 0 or 1 (only available for meshdim=2) \n - PLANAR_FACE_5, PLANAR_FACE_6 (only for meshdim=3)"); - } + } } /// @cond INTERNAL @@ -964,37 +1010,61 @@ DataArrayInt *MEDCoupling1SGTUMesh::simplexize(int policy) throw(INTERP_KERNEL:: struct MEDCouplingAccVisit { MEDCouplingAccVisit():_new_nb_of_nodes(0) { } - int operator()(int val) { if(val!=-1) return _new_nb_of_nodes++; else return -1; } - int _new_nb_of_nodes; + mcIdType operator()(mcIdType val) { if(val!=-1) return _new_nb_of_nodes++; else return -1; } + mcIdType _new_nb_of_nodes; }; /// @endcond +/*! + * This method returns all node ids used in \b this. The data array returned has to be dealt by the caller. + * The returned node ids are sortes ascendingly. This method is closed to MEDCoupling1SGTUMesh::getNodeIdsInUse except + * the format of returned DataArrayIdType instance. + * + * \return a newly allocated DataArrayIdType sorted ascendingly of fetched node ids. + * \sa MEDCoupling1SGTUMesh::getNodeIdsInUse, areAllNodesFetched + */ +DataArrayIdType *MEDCoupling1SGTUMesh::computeFetchedNodeIds() const +{ + checkConsistencyOfConnectivity(); + mcIdType nbNodes(getNumberOfNodes()); + std::vector fetchedNodes(nbNodes,false); + computeNodeIdsAlg(fetchedNodes); + mcIdType sz(ToIdType(std::count(fetchedNodes.begin(),fetchedNodes.end(),true))); + MCAuto ret(DataArrayIdType::New()); ret->alloc(sz,1); + mcIdType *retPtr(ret->getPointer()); + for(mcIdType i=0;igetNumberOfNodes(). It holds for each node of \a this mesh either -1 * if the node is unused or a new id else. The caller is to delete this * array using decrRef() as it is no more needed. * \throw If the coordinates array is not set. * \throw If the nodal connectivity of cells is not defined. * \throw If the nodal connectivity includes an invalid id. + * \sa MEDCoupling1SGTUMesh::computeFetchedNodeIds, areAllNodesFetched */ -DataArrayInt *MEDCoupling1SGTUMesh::getNodeIdsInUse(int& nbrOfNodesInUse) const throw(INTERP_KERNEL::Exception) +DataArrayIdType *MEDCoupling1SGTUMesh::getNodeIdsInUse(mcIdType& nbrOfNodesInUse) const { nbrOfNodesInUse=-1; - int nbOfNodes=getNumberOfNodes(); - int nbOfCells=getNumberOfCells(); - MEDCouplingAutoRefCountObjectPtr ret=DataArrayInt::New(); + mcIdType nbOfNodes=getNumberOfNodes(); + mcIdType nbOfCells=getNumberOfCells(); + MCAuto ret(DataArrayIdType::New()); ret->alloc(nbOfNodes,1); - int *traducer=ret->getPointer(); + mcIdType *traducer=ret->getPointer(); std::fill(traducer,traducer+nbOfNodes,-1); - const int *conn=_conn->begin(); - int nbNodesPerCell=getNumberOfNodesPerCell(); - for(int i=0;ibegin(); + mcIdType nbNodesPerCell=getNumberOfNodesPerCell(); + for(mcIdType i=0;i=0 && *connapplyLin(1,offset); + updateTime(); +} + +/*! + * Same than renumberNodesInConn(const mcIdType *) except that here the format of old-to-new traducer is using map instead + * of array. This method is dedicated for renumbering from a big set of nodes the a tiny set of nodes which is the case during extraction + * of a big mesh. + */ +void MEDCoupling1SGTUMesh::renumberNodesInConn(const INTERP_KERNEL::HashMap& newNodeNumbersO2N) +{ + this->renumberNodesInConnT< INTERP_KERNEL::HashMap >(newNodeNumbersO2N); +} + +/*! + * Same than renumberNodesInConn(const mcIdType *) except that here the format of old-to-new traducer is using map instead + * of array. This method is dedicated for renumbering from a big set of nodes the a tiny set of nodes which is the case during extraction + * of a big mesh. + */ +void MEDCoupling1SGTUMesh::renumberNodesInConn(const std::map& newNodeNumbersO2N) +{ + this->renumberNodesInConnT< std::map >(newNodeNumbersO2N); +} + /*! * Changes ids of nodes within the nodal connectivity arrays according to a permutation * array in "Old to New" mode. The node coordinates array is \b not changed by this method. @@ -1015,24 +1120,24 @@ DataArrayInt *MEDCoupling1SGTUMesh::getNodeIdsInUse(int& nbrOfNodesInUse) const * \warning This method performs no check of validity of new ids. **Use it with care !** * \param [in] newNodeNumbersO2N - a permutation array, of length \a * this->getNumberOfNodes(), in "Old to New" mode. - * See \ref MEDCouplingArrayRenumbering for more info on renumbering modes. + * See \ref numbering for more info on renumbering modes. * \throw If the nodal connectivity of cells is not defined. */ -void MEDCoupling1SGTUMesh::renumberNodesInConn(const int *newNodeNumbersO2N) +void MEDCoupling1SGTUMesh::renumberNodesInConn(const mcIdType *newNodeNumbersO2N) { getNumberOfCells();//only to check that all is well defined. _conn->transformWithIndArr(newNodeNumbersO2N,newNodeNumbersO2N+getNumberOfNodes()); updateTime(); } -MEDCoupling1SGTUMesh *MEDCoupling1SGTUMesh::Merge1SGTUMeshes(const MEDCoupling1SGTUMesh *mesh1, const MEDCoupling1SGTUMesh *mesh2) throw(INTERP_KERNEL::Exception) +MEDCoupling1SGTUMesh *MEDCoupling1SGTUMesh::Merge1SGTUMeshes(const MEDCoupling1SGTUMesh *mesh1, const MEDCoupling1SGTUMesh *mesh2) { std::vector tmp(2); tmp[0]=const_cast(mesh1); tmp[1]=const_cast(mesh2); return Merge1SGTUMeshes(tmp); } -MEDCoupling1SGTUMesh *MEDCoupling1SGTUMesh::Merge1SGTUMeshes(std::vector& a) throw(INTERP_KERNEL::Exception) +MEDCoupling1SGTUMesh *MEDCoupling1SGTUMesh::Merge1SGTUMeshes(std::vector& a) { std::size_t sz=a.size(); if(sz==0) @@ -1047,17 +1152,17 @@ MEDCoupling1SGTUMesh *MEDCoupling1SGTUMesh::Merge1SGTUMeshes(std::vectorgetCellModel())!=cm) throw INTERP_KERNEL::Exception("MEDCoupling1SGTUMesh::Merge1SGTUMeshes : all items must have the same geo type !"); - std::vector< MEDCouplingAutoRefCountObjectPtr > bb(sz); + std::vector< MCAuto > bb(sz); std::vector< const MEDCoupling1SGTUMesh * > aa(sz); - int spaceDim=-3; - for(std::size_t i=0;igetCoords(); if(coo) spaceDim=coo->getNumberOfComponents(); } - if(spaceDim==-3) + if(spaceDim==spaceDimUndef) throw INTERP_KERNEL::Exception("MEDCoupling1SGTUMesh::Merge1SGTUMeshes : no spaceDim specified ! unable to perform merge !"); for(std::size_t i=0;i& a) throw(INTERP_KERNEL::Exception) +MEDCoupling1SGTUMesh *MEDCoupling1SGTUMesh::Merge1SGTUMeshesOnSameCoords(std::vector& a) { if(a.empty()) throw INTERP_KERNEL::Exception("MEDCoupling1SGTUMesh::Merge1SGTUMeshesOnSameCoords : input array must be NON EMPTY !"); std::vector::const_iterator it=a.begin(); if(!(*it)) throw INTERP_KERNEL::Exception("MEDCoupling1SGTUMesh::Merge1SGTUMeshesOnSameCoords : null instance in the first element of input vector !"); - std::vector ncs(a.size()); - int nbOfCells=(*it)->getNumberOfCells(); + std::vector ncs(a.size()); + (*it)->getNumberOfCells();//to check that all is OK const DataArrayDouble *coords=(*it)->getCoords(); const INTERP_KERNEL::CellModel *cm=&((*it)->getCellModel()); - int nbNodesPerCell=(*it)->getNumberOfNodesPerCell(); ncs[0]=(*it)->getNodalConnectivity(); it++; for(int i=1;it!=a.end();i++,it++) @@ -1096,23 +1200,23 @@ MEDCoupling1SGTUMesh *MEDCoupling1SGTUMesh::Merge1SGTUMeshesOnSameCoords(std::ve if(coords!=(*it)->getCoords()) throw INTERP_KERNEL::Exception("MEDCoupling1SGTUMesh::Merge1SGTUMeshesOnSameCoords : not lying on same coords !"); } - MEDCouplingAutoRefCountObjectPtr ret(new MEDCoupling1SGTUMesh("merge",*cm)); + MCAuto ret(new MEDCoupling1SGTUMesh("merge",*cm)); ret->setCoords(coords); - ret->_conn=DataArrayInt::Aggregate(ncs); + ret->_conn=DataArrayIdType::Aggregate(ncs); return ret.retn(); } /*! * Assume that all instances in \a a are non null. If null it leads to a crash. That's why this method is assigned to be low level (LL) */ -MEDCoupling1SGTUMesh *MEDCoupling1SGTUMesh::Merge1SGTUMeshesLL(std::vector& a) throw(INTERP_KERNEL::Exception) +MEDCoupling1SGTUMesh *MEDCoupling1SGTUMesh::Merge1SGTUMeshesLL(std::vector& a) { if(a.empty()) throw INTERP_KERNEL::Exception("MEDCoupling1SGTUMesh::Merge1SGTUMeshes : input array must be NON EMPTY !"); std::vector::const_iterator it=a.begin(); - int nbOfCells=(*it)->getNumberOfCells(); + mcIdType nbOfCells=(*it)->getNumberOfCells(); const INTERP_KERNEL::CellModel *cm=&((*it)->getCellModel()); - int nbNodesPerCell=(*it)->getNumberOfNodesPerCell(); + mcIdType nbNodesPerCell=(*it)->getNumberOfNodesPerCell(); it++; for(;it!=a.end();it++) { @@ -1122,18 +1226,18 @@ MEDCoupling1SGTUMesh *MEDCoupling1SGTUMesh::Merge1SGTUMeshesLL(std::vector aps(a.size()); std::copy(a.begin(),a.end(),aps.begin()); - MEDCouplingAutoRefCountObjectPtr pts=MergeNodesArray(aps); - MEDCouplingAutoRefCountObjectPtr ret(new MEDCoupling1SGTUMesh("merge",*cm)); + MCAuto pts=MergeNodesArray(aps); + MCAuto ret(new MEDCoupling1SGTUMesh("merge",*cm)); ret->setCoords(pts); - MEDCouplingAutoRefCountObjectPtr c=DataArrayInt::New(); + MCAuto c=DataArrayIdType::New(); c->alloc(nbOfCells*nbNodesPerCell,1); - int *cPtr=c->getPointer(); - int offset=0; + mcIdType *cPtr=c->getPointer(); + mcIdType offset=0; for(it=a.begin();it!=a.end();it++) { - int curConnLgth=(*it)->getNodalConnectivityLength(); - const int *curC=(*it)->_conn->begin(); - cPtr=std::transform(curC,curC+curConnLgth,cPtr,std::bind2nd(std::plus(),offset)); + mcIdType curConnLgth=(*it)->getNodalConnectivityLength(); + const mcIdType *curC=(*it)->_conn->begin(); + cPtr=std::transform(curC,curC+curConnLgth,cPtr,std::bind(std::plus(),std::placeholders::_1,offset)); offset+=(*it)->getNumberOfNodes(); } // @@ -1141,17 +1245,17 @@ MEDCoupling1SGTUMesh *MEDCoupling1SGTUMesh::Merge1SGTUMeshesLL(std::vector ret(new MEDCoupling1SGTUMesh(getName().c_str(),*_cm)); + mcIdType ncell=getNumberOfCells(); + MCAuto ret(new MEDCoupling1SGTUMesh(getName(),*_cm)); ret->setCoords(_coords); std::size_t nbOfElemsRet=std::distance(begin,end); - const int *inConn=_conn->getConstPointer(); - int sz=getNumberOfNodesPerCell(); - MEDCouplingAutoRefCountObjectPtr connRet=DataArrayInt::New(); connRet->alloc((int)nbOfElemsRet*sz,1); - int *connPtr=connRet->getPointer(); - for(const int *work=begin;work!=end;work++,connPtr+=sz) + const mcIdType *inConn=_conn->getConstPointer(); + mcIdType sz=getNumberOfNodesPerCell(); + MCAuto connRet=DataArrayIdType::New(); connRet->alloc(nbOfElemsRet*sz,1); + mcIdType *connPtr=connRet->getPointer(); + for(const mcIdType *work=begin;work!=end;work++,connPtr+=sz) { if(*work>=0 && *work ret(new MEDCoupling1SGTUMesh(getName().c_str(),*_cm)); + mcIdType ncell=getNumberOfCells(); + mcIdType nbOfElemsRet=DataArray::GetNumberOfItemGivenBESRelative(start,end,step,"MEDCoupling1SGTUMesh::buildPartOfMySelfKeepCoordsSlice : "); + MCAuto ret(new MEDCoupling1SGTUMesh(getName(),*_cm)); ret->setCoords(_coords); - const int *inConn=_conn->getConstPointer(); - int sz=getNumberOfNodesPerCell(); - MEDCouplingAutoRefCountObjectPtr connRet=DataArrayInt::New(); connRet->alloc((int)nbOfElemsRet*sz,1); - int *connPtr=connRet->getPointer(); - int curId=start; - for(int i=0;igetConstPointer(); + mcIdType sz=getNumberOfNodesPerCell(); + MCAuto connRet=DataArrayIdType::New(); connRet->alloc(nbOfElemsRet*sz,1); + mcIdType *connPtr=connRet->getPointer(); + mcIdType curId=start; + for(mcIdType i=0;i=0 && curId& nodeIdsInUse) const throw(INTERP_KERNEL::Exception) +void MEDCoupling1SGTUMesh::computeNodeIdsAlg(std::vector& nodeIdsInUse) const { - int sz((int)nodeIdsInUse.size()); - int nbCells(getNumberOfCells()); - int nbOfNodesPerCell(getNumberOfNodesPerCell()); - const int *w(_conn->begin()); - for(int i=0;i=0 && *wbegin();conn!=_conn->end();conn++) + { + if(*conn>=0 && *connbegin(),conn) << " value is " << *conn << " must be in [0," << sz << ") !"; + throw INTERP_KERNEL::Exception(oss.str().c_str()); + } + } } -MEDCoupling1SGTUMesh *MEDCoupling1SGTUMesh::buildSetInstanceFromThis(int spaceDim) const throw(INTERP_KERNEL::Exception) +MEDCoupling1SGTUMesh *MEDCoupling1SGTUMesh::buildSetInstanceFromThis(std::size_t spaceDim) const { - MEDCouplingAutoRefCountObjectPtr ret(new MEDCoupling1SGTUMesh(getName().c_str(),*_cm)); - MEDCouplingAutoRefCountObjectPtr tmp1; - const DataArrayInt *nodalConn(_conn); + MCAuto ret(new MEDCoupling1SGTUMesh(getName(),*_cm)); + MCAuto tmp1; + const DataArrayIdType *nodalConn(_conn); if(!nodalConn) { - tmp1=DataArrayInt::New(); tmp1->alloc(0,1); + tmp1=DataArrayIdType::New(); tmp1->alloc(0,1); } else tmp1=_conn; ret->_conn=tmp1; if(!_coords) { - MEDCouplingAutoRefCountObjectPtr coords=DataArrayDouble::New(); coords->alloc(0,spaceDim); + MCAuto coords=DataArrayDouble::New(); coords->alloc(0,spaceDim); ret->setCoords(coords); } else @@ -1233,16 +1333,16 @@ MEDCoupling1SGTUMesh *MEDCoupling1SGTUMesh::buildSetInstanceFromThis(int spaceDi return ret.retn(); } -DataArrayInt *MEDCoupling1SGTUMesh::simplexizePol0() throw(INTERP_KERNEL::Exception) +DataArrayIdType *MEDCoupling1SGTUMesh::simplexizePol0() { - int nbOfCells=getNumberOfCells(); + mcIdType nbOfCells=getNumberOfCells(); if(getCellModelEnum()!=INTERP_KERNEL::NORM_QUAD4) - return DataArrayInt::Range(0,nbOfCells,1); - MEDCouplingAutoRefCountObjectPtr newConn=DataArrayInt::New(); newConn->alloc(2*3*nbOfCells,1); - MEDCouplingAutoRefCountObjectPtr ret=DataArrayInt::New(); ret->alloc(2*nbOfCells,1); - const int *c(_conn->begin()); - int *retPtr(ret->getPointer()),*newConnPtr(newConn->getPointer()); - for(int i=0;i newConn=DataArrayIdType::New(); newConn->alloc(2*3*nbOfCells,1); + MCAuto ret=DataArrayIdType::New(); ret->alloc(2*nbOfCells,1); + const mcIdType *c(_conn->begin()); + mcIdType *retPtr(ret->getPointer()),*newConnPtr(newConn->getPointer()); + for(mcIdType i=0;i newConn=DataArrayInt::New(); newConn->alloc(2*3*nbOfCells,1); - MEDCouplingAutoRefCountObjectPtr ret=DataArrayInt::New(); ret->alloc(2*nbOfCells,1); - const int *c(_conn->begin()); - int *retPtr(ret->getPointer()),*newConnPtr(newConn->getPointer()); - for(int i=0;i newConn=DataArrayIdType::New(); newConn->alloc(2*3*nbOfCells,1); + MCAuto ret=DataArrayIdType::New(); ret->alloc(2*nbOfCells,1); + const mcIdType *c(_conn->begin()); + mcIdType *retPtr(ret->getPointer()),*newConnPtr(newConn->getPointer()); + for(mcIdType i=0;i newConn=DataArrayInt::New(); newConn->alloc(5*4*nbOfCells,1); - MEDCouplingAutoRefCountObjectPtr ret=DataArrayInt::New(); ret->alloc(5*nbOfCells,1); - const int *c(_conn->begin()); - int *retPtr(ret->getPointer()),*newConnPtr(newConn->getPointer()); - for(int i=0;i newConn=DataArrayIdType::New(); newConn->alloc(5*4*nbOfCells,1); + MCAuto ret=DataArrayIdType::New(); ret->alloc(5*nbOfCells,1); + const mcIdType *c(_conn->begin()); + mcIdType *retPtr(ret->getPointer()),*newConnPtr(newConn->getPointer()); + for(mcIdType i=0;i newConn=DataArrayInt::New(); newConn->alloc(6*4*nbOfCells,1); - MEDCouplingAutoRefCountObjectPtr ret=DataArrayInt::New(); ret->alloc(6*nbOfCells,1); - const int *c(_conn->begin()); - int *retPtr(ret->getPointer()),*newConnPtr(newConn->getPointer()); - for(int i=0;i newConn=DataArrayIdType::New(); newConn->alloc(6*4*nbOfCells,1); + MCAuto ret=DataArrayIdType::New(); ret->alloc(6*nbOfCells,1); + const mcIdType *c(_conn->begin()); + mcIdType *retPtr(ret->getPointer()),*newConnPtr(newConn->getPointer()); + for(mcIdType i=0;igetRepr() << ". Name : \"" << getName() << "\"."; stream << " Mesh dimension : " << getMeshDimension() << "."; if(!_coords) { stream << " No coordinates set !"; return ; } @@ -1327,7 +1433,7 @@ void MEDCoupling1SGTUMesh::reprQuickOverview(std::ostream& stream) const throw(I { stream << " Coordinates set but not allocated !"; return ; } stream << " Space dimension : " << _coords->getNumberOfComponents() << "." << std::endl; stream << "Number of nodes : " << _coords->getNumberOfTuples() << "."; - if(!(const DataArrayInt *)_conn) + if(!(const DataArrayIdType *)_conn) { stream << std::endl << "Nodal connectivity NOT set !"; return ; } if(_conn->isAllocated()) { @@ -1336,20 +1442,108 @@ void MEDCoupling1SGTUMesh::reprQuickOverview(std::ostream& stream) const throw(I } } -void MEDCoupling1SGTUMesh::checkFullyDefined() const throw(INTERP_KERNEL::Exception) +void MEDCoupling1SGTUMesh::checkFullyDefined() const { - if(!((const DataArrayInt *)_conn) || !((const DataArrayDouble *)_coords)) + if(!((const DataArrayIdType *)_conn) || !((const DataArrayDouble *)_coords)) throw INTERP_KERNEL::Exception("MEDCoupling1SGTUMesh::checkFullyDefined : part of this is not fully defined."); } /*! * First step of unserialization process. */ -bool MEDCoupling1SGTUMesh::isEmptyMesh(const std::vector& tinyInfo) const +bool MEDCoupling1SGTUMesh::isEmptyMesh(const std::vector& tinyInfo) const { throw INTERP_KERNEL::Exception("MEDCoupling1SGTUMesh::isEmptyMesh : not implemented yet !"); } +void MEDCoupling1SGTUMesh::getTinySerializationInformation(std::vector& tinyInfoD, std::vector& tinyInfo, std::vector& littleStrings) const +{ + int it,order; + double time=getTime(it,order); + tinyInfo.clear(); tinyInfoD.clear(); littleStrings.clear(); + // + littleStrings.push_back(getName()); + littleStrings.push_back(getDescription()); + littleStrings.push_back(getTimeUnit()); + // + std::vector littleStrings2,littleStrings3; + if((const DataArrayDouble *)_coords) + _coords->getTinySerializationStrInformation(littleStrings2); + if((const DataArrayIdType *)_conn) + _conn->getTinySerializationStrInformation(littleStrings3); + mcIdType sz0(ToIdType(littleStrings2.size())),sz1(ToIdType(littleStrings3.size())); + littleStrings.insert(littleStrings.end(),littleStrings2.begin(),littleStrings2.end()); + littleStrings.insert(littleStrings.end(),littleStrings3.begin(),littleStrings3.end()); + // + tinyInfo.push_back(getCellModelEnum()); + tinyInfo.push_back(it); + tinyInfo.push_back(order); + std::vector tinyInfo2,tinyInfo3; + if((const DataArrayDouble *)_coords) + _coords->getTinySerializationIntInformation(tinyInfo2); + if((const DataArrayIdType *)_conn) + _conn->getTinySerializationIntInformation(tinyInfo3); + mcIdType sz2(ToIdType(tinyInfo2.size())),sz3(ToIdType(tinyInfo3.size())); + tinyInfo.push_back(sz0); tinyInfo.push_back(sz1); tinyInfo.push_back(sz2); tinyInfo.push_back(sz3); + tinyInfo.insert(tinyInfo.end(),tinyInfo2.begin(),tinyInfo2.end()); + tinyInfo.insert(tinyInfo.end(),tinyInfo3.begin(),tinyInfo3.end()); + // + tinyInfoD.push_back(time); +} + +void MEDCoupling1SGTUMesh::resizeForUnserialization(const std::vector& tinyInfo, DataArrayIdType *a1, DataArrayDouble *a2, std::vector& littleStrings) const +{ + std::vector tinyInfo2(tinyInfo.begin()+7,tinyInfo.begin()+7+tinyInfo[5]); + std::vector tinyInfo1(tinyInfo.begin()+7+tinyInfo[5],tinyInfo.begin()+7+tinyInfo[5]+tinyInfo[6]); + a1->resizeForUnserialization(tinyInfo1); + a2->resizeForUnserialization(tinyInfo2); +} + +void MEDCoupling1SGTUMesh::serialize(DataArrayIdType *&a1, DataArrayDouble *&a2) const +{ + mcIdType sz(0); + if((const DataArrayIdType *)_conn) + if(_conn->isAllocated()) + sz=_conn->getNbOfElems(); + a1=DataArrayIdType::New(); + a1->alloc(sz,1); + if(sz!=0 && (const DataArrayIdType *)_conn) + std::copy(_conn->begin(),_conn->end(),a1->getPointer()); + sz=0; + if((const DataArrayDouble *)_coords) + if(_coords->isAllocated()) + sz=_coords->getNbOfElems(); + a2=DataArrayDouble::New(); + a2->alloc(sz,1); + if(sz!=0 && (const DataArrayDouble *)_coords) + std::copy(_coords->begin(),_coords->end(),a2->getPointer()); +} + +void MEDCoupling1SGTUMesh::unserialization(const std::vector& tinyInfoD, const std::vector& tinyInfo, const DataArrayIdType *a1, DataArrayDouble *a2, + const std::vector& littleStrings) +{ + INTERP_KERNEL::NormalizedCellType gt((INTERP_KERNEL::NormalizedCellType)tinyInfo[0]); + _cm=&INTERP_KERNEL::CellModel::GetCellModel(gt); + setName(littleStrings[0]); + setDescription(littleStrings[1]); + setTimeUnit(littleStrings[2]); + setTime(tinyInfoD[0],FromIdType(tinyInfo[1]),FromIdType(tinyInfo[2])); + mcIdType sz0(tinyInfo[3]),sz1(tinyInfo[4]),sz2(tinyInfo[5]),sz3(tinyInfo[6]); + // + _coords=DataArrayDouble::New(); + std::vector tinyInfo2(tinyInfo.begin()+7,tinyInfo.begin()+7+sz2); + _coords->resizeForUnserialization(tinyInfo2); + std::copy(a2->begin(),a2->end(),_coords->getPointer()); + _conn=DataArrayIdType::New(); + std::vector tinyInfo3(tinyInfo.begin()+7+sz2,tinyInfo.begin()+7+sz2+sz3); + _conn->resizeForUnserialization(tinyInfo3); + std::copy(a1->begin(),a1->end(),_conn->getPointer()); + std::vector littleStrings2(littleStrings.begin()+3,littleStrings.begin()+3+sz0); + _coords->finishUnserialization(tinyInfo2,littleStrings2); + std::vector littleStrings3(littleStrings.begin()+3+sz0,littleStrings.begin()+3+sz0+sz1); + _conn->finishUnserialization(tinyInfo3,littleStrings3); +} + /*! * Checks if \a this and \a other meshes are geometrically equivalent with high * probability, else an exception is thrown. The meshes are considered equivalent if @@ -1360,13 +1554,13 @@ bool MEDCoupling1SGTUMesh::isEmptyMesh(const std::vector& tinyInfo) const * \param [in] prec - the precision used to compare nodes of the two meshes. * \throw If the two meshes do not match. */ -void MEDCoupling1SGTUMesh::checkFastEquivalWith(const MEDCouplingMesh *other, double prec) const throw(INTERP_KERNEL::Exception) +void MEDCoupling1SGTUMesh::checkFastEquivalWith(const MEDCouplingMesh *other, double prec) const { MEDCouplingPointSet::checkFastEquivalWith(other,prec); const MEDCoupling1SGTUMesh *otherC=dynamic_cast(other); if(!otherC) throw INTERP_KERNEL::Exception("MEDCoupling1SGTUMesh::checkFastEquivalWith : Two meshes are not unstructured with single static geometric type !"); - const DataArrayInt *c1(_conn),*c2(otherC->_conn); + const DataArrayIdType *c1(_conn),*c2(otherC->_conn); if(c1==c2) return; if(!c1 || !c2) @@ -1392,18 +1586,18 @@ MEDCouplingPointSet *MEDCoupling1SGTUMesh::mergeMyselfWithOnSameCoords(const MED return Merge1SGTUMeshesOnSameCoords(ms); } -void MEDCoupling1SGTUMesh::getReverseNodalConnectivity(DataArrayInt *revNodal, DataArrayInt *revNodalIndx) const throw(INTERP_KERNEL::Exception) +void MEDCoupling1SGTUMesh::getReverseNodalConnectivity(DataArrayIdType *revNodal, DataArrayIdType *revNodalIndx) const { checkFullyDefined(); - int nbOfNodes=getNumberOfNodes(); - int *revNodalIndxPtr=(int *)malloc((nbOfNodes+1)*sizeof(int)); - revNodalIndx->useArray(revNodalIndxPtr,true,C_DEALLOC,nbOfNodes+1,1); + mcIdType nbOfNodes=getNumberOfNodes(); + mcIdType *revNodalIndxPtr=(mcIdType *)malloc((nbOfNodes+1)*sizeof(mcIdType)); + revNodalIndx->useArray(revNodalIndxPtr,true,DeallocType::C_DEALLOC,nbOfNodes+1,1); std::fill(revNodalIndxPtr,revNodalIndxPtr+nbOfNodes+1,0); - const int *conn=_conn->begin(); - int nbOfCells=getNumberOfCells(); - int nbOfEltsInRevNodal=0; - int nbOfNodesPerCell=getNumberOfNodesPerCell(); - for(int eltId=0;eltIdbegin(); + mcIdType nbOfCells=getNumberOfCells(); + mcIdType nbOfEltsInRevNodal=0; + mcIdType nbOfNodesPerCell=getNumberOfNodesPerCell(); + for(mcIdType eltId=0;eltId()); + std::transform(revNodalIndxPtr+1,revNodalIndxPtr+nbOfNodes+1,revNodalIndxPtr,revNodalIndxPtr+1,std::plus()); conn=_conn->begin(); - int *revNodalPtr=(int *)malloc((nbOfEltsInRevNodal)*sizeof(int)); - revNodal->useArray(revNodalPtr,true,C_DEALLOC,nbOfEltsInRevNodal,1); + mcIdType *revNodalPtr=(mcIdType *)malloc(nbOfEltsInRevNodal*sizeof(mcIdType)); + revNodal->useArray(revNodalPtr,true,DeallocType::C_DEALLOC,nbOfEltsInRevNodal,1); std::fill(revNodalPtr,revNodalPtr+nbOfEltsInRevNodal,-1); - for(int eltId=0;eltId(),-1))=eltId; + *std::find_if(revNodalPtr+revNodalIndxPtr[*conn],revNodalPtr+revNodalIndxPtr[*conn+1],std::bind(std::equal_to(),std::placeholders::_1,-1))=eltId; } } } @@ -1436,7 +1630,7 @@ void MEDCoupling1SGTUMesh::getReverseNodalConnectivity(DataArrayInt *revNodal, D /*! * Use \a nodalConn array as nodal connectivity of \a this. The input \a nodalConn pointer can be null. */ -void MEDCoupling1SGTUMesh::setNodalConnectivity(DataArrayInt *nodalConn) throw(INTERP_KERNEL::Exception) +void MEDCoupling1SGTUMesh::setNodalConnectivity(DataArrayIdType *nodalConn) { if(nodalConn) nodalConn->incrRef(); @@ -1445,26 +1639,26 @@ void MEDCoupling1SGTUMesh::setNodalConnectivity(DataArrayInt *nodalConn) throw(I } /*! - * \return DataArrayInt * - the internal reference to the nodal connectivity. The caller is not reponsible to deallocate it. + * \return DataArrayIdType * - the internal reference to the nodal connectivity. The caller is not responsible to deallocate it. */ -DataArrayInt *MEDCoupling1SGTUMesh::getNodalConnectivity() const throw(INTERP_KERNEL::Exception) +DataArrayIdType *MEDCoupling1SGTUMesh::getNodalConnectivity() const { - const DataArrayInt *ret(_conn); - return const_cast(ret); + const DataArrayIdType *ret(_conn); + return const_cast(ret); } /*! * Allocates memory to store an estimation of the given number of cells. Closer is the estimation to the number of cells effectively inserted, * less will be the needs to realloc. If the number of cells to be inserted is not known simply put 0 to this parameter. - * If a nodal connectivity previouly existed before the call of this method, it will be reset. + * If a nodal connectivity previously existed before the call of this method, it will be reset. * * \param [in] nbOfCells - estimation of the number of cell \a this mesh will contain. */ -void MEDCoupling1SGTUMesh::allocateCells(int nbOfCells) throw(INTERP_KERNEL::Exception) +void MEDCoupling1SGTUMesh::allocateCells(mcIdType nbOfCells) { if(nbOfCells<0) throw INTERP_KERNEL::Exception("MEDCoupling1SGTUMesh::allocateCells : the input number of cells should be >= 0 !"); - _conn=DataArrayInt::New(); + _conn=DataArrayIdType::New(); _conn->reserve(getNumberOfNodesPerCell()*nbOfCells); declareAsNew(); } @@ -1476,15 +1670,15 @@ void MEDCoupling1SGTUMesh::allocateCells(int nbOfCells) throw(INTERP_KERNEL::Exc * \param [in] nodalConnOfCellEnd - the end (excluded) of nodal connectivity of the cell to add. * \throw If the length of the input nodal connectivity array of the cell to add is not equal to number of nodes per cell relative to the unique geometric type * attached to \a this. - * \thow If the nodal connectivity array in \a this is null (call MEDCoupling1SGTUMesh::allocateCells before). + * \throw If the nodal connectivity array in \a this is null (call MEDCoupling1SGTUMesh::allocateCells before). */ -void MEDCoupling1SGTUMesh::insertNextCell(const int *nodalConnOfCellBg, const int *nodalConnOfCellEnd) throw(INTERP_KERNEL::Exception) +void MEDCoupling1SGTUMesh::insertNextCell(const mcIdType *nodalConnOfCellBg, const mcIdType *nodalConnOfCellEnd) { - int sz=(int)std::distance(nodalConnOfCellBg,nodalConnOfCellEnd); - int ref=getNumberOfNodesPerCell(); + mcIdType sz=ToIdType(std::distance(nodalConnOfCellBg,nodalConnOfCellEnd)); + mcIdType ref=getNumberOfNodesPerCell(); if(sz==ref) { - DataArrayInt *c(_conn); + DataArrayIdType *c(_conn); if(c) c->pushBackValsSilent(nodalConnOfCellBg,nodalConnOfCellEnd); else @@ -1498,9 +1692,485 @@ void MEDCoupling1SGTUMesh::insertNextCell(const int *nodalConnOfCellBg, const in } } +/*! + * This method builds the dual mesh of \a this and returns it. + * + * \return MEDCoupling1SGTUMesh * - newly object created to be managed by the caller. + * \throw If \a this is not a mesh containing only simplex cells. + * \throw If \a this is not correctly allocated (coordinates and connectivities have to be correctly set !). + * \throw If at least one node in \a this is orphan (without any simplex cell lying on it !) + */ +MEDCoupling1GTUMesh *MEDCoupling1SGTUMesh::computeDualMesh() const +{ + const INTERP_KERNEL::CellModel& cm(getCellModel()); + if(!cm.isSimplex()) + throw INTERP_KERNEL::Exception("MEDCoupling1SGTUMesh::computeDualMesh : this mesh is not a simplex mesh ! Please invoke simplexize of tetrahedrize on this before calling this method !"); + switch(getMeshDimension()) + { + case 3: + return computeDualMesh3D(); + case 2: + return computeDualMesh2D(); + default: + throw INTERP_KERNEL::Exception("MEDCoupling1SGTUMesh::computeDualMesh : meshdimension must be in [2,3] !"); + } +} + +/*! + * This method explode each NORM_HEXA8 cells in \a this into 6 NORM_QUAD4 cells and put the result into the MEDCoupling1SGTUMesh returned instance. + * + * \return MEDCoupling1SGTUMesh * - a newly allocated instances (to be managed by the caller) storing the result of the explosion. + * \throw If \a this is not a mesh containing only NORM_HEXA8 cells. + * \throw If \a this is not properly allocated. + */ +MEDCoupling1SGTUMesh *MEDCoupling1SGTUMesh::explodeEachHexa8To6Quad4() const +{ + const INTERP_KERNEL::CellModel& cm(getCellModel()); + if(cm.getEnum()!=INTERP_KERNEL::NORM_HEXA8) + throw INTERP_KERNEL::Exception("MEDCoupling1SGTUMesh::explodeEachHexa8To6Quad4 : this method can be applied only on HEXA8 mesh !"); + mcIdType nbHexa8=getNumberOfCells(); + const mcIdType *inConnPtr(getNodalConnectivity()->begin()); + MCAuto ret(MEDCoupling1SGTUMesh::New(getName(),INTERP_KERNEL::NORM_QUAD4)); + MCAuto c(DataArrayIdType::New()); c->alloc(nbHexa8*6*4,1); + mcIdType *cPtr(c->getPointer()); + for(mcIdType i=0;isetCoords(getCoords()); + ret->setNodalConnectivity(c); + return ret.retn(); +} + +/*! + * This method starts from an unstructured mesh that hides in reality a cartesian mesh. + * If it is not the case, an exception will be thrown. + * This method returns three objects : The cartesian mesh geometrically equivalent to \a this (within a precision of \a eps) and a permutation of cells + * and a permutation of nodes. + * + * - this[cellPerm[i]]=ret[i] + * + * \param [out] cellPerm the permutation array of size \c this->getNumberOfCells() + * \param [out] nodePerm the permutation array of size \c this->getNumberOfNodes() + * \return MEDCouplingCMesh * - a newly allocated mesh that is the result of the structurization of \a this. + */ +MEDCouplingCMesh *MEDCoupling1SGTUMesh::structurizeMe(DataArrayIdType *& cellPerm, DataArrayIdType *& nodePerm, double eps) const +{ + checkConsistencyLight(); + int spaceDim(getSpaceDimension()),meshDim(getMeshDimension()); mcIdType nbNodes(getNumberOfNodes()); + if(MEDCouplingStructuredMesh::GetGeoTypeGivenMeshDimension(meshDim)!=getCellModelEnum()) + throw INTERP_KERNEL::Exception("MEDCoupling1SGTUMesh::structurizeMe : the unique geo type in this is not compatible with the geometric type regarding mesh dimension !"); + MCAuto cm(MEDCouplingCMesh::New()); + for(int i=0;i tmp(1,i); + MCAuto elt(static_cast(getCoords()->keepSelectedComponents(tmp))); + elt=elt->getDifferentValues(eps); + elt->sort(true); + cm->setCoordsAt(i,elt); + } + if(nbNodes!=cm->getNumberOfNodes()) + throw INTERP_KERNEL::Exception("MEDCoupling1SGTUMesh::structurizeMe : considering the number of nodes after split per components in space this can't be a cartesian mesh ! Maybe your epsilon parameter is invalid ?"); + try + { cm->copyTinyInfoFrom(this); } + catch(INTERP_KERNEL::Exception&) { } + MCAuto um(cm->buildUnstructured()),self(buildUnstructured()); + self->checkGeoEquivalWith(um,12,eps,cellPerm,nodePerm); + return cm.retn(); +} + +/// @cond INTERNAL + +bool UpdateHexa8Cell(int validAxis, mcIdType neighId, const mcIdType *validConnQuad4NeighSide, mcIdType *allFacesNodalConn, mcIdType *myNeighbours) +{ + static const int TAB[48]={ + 0,1,2,3,4,5,6,7,//0 + 4,7,6,5,0,3,2,1,//1 + 0,3,7,4,1,2,6,5,//2 + 4,0,3,7,5,1,2,6,//3 + 5,1,0,4,6,2,3,7,//4 + 3,7,4,0,2,6,5,1 //5 + }; + static const int TAB2[6]={0,0,3,3,3,3}; + if(myNeighbours[validAxis]==neighId && allFacesNodalConn[4*validAxis+0]==validConnQuad4NeighSide[TAB2[validAxis]]) + return true; + mcIdType oldAxis(ToIdType(std::distance(myNeighbours,std::find(myNeighbours,myNeighbours+6,neighId)))); + std::size_t pos(std::distance(MEDCoupling1SGTUMesh::HEXA8_FACE_PAIRS,std::find(MEDCoupling1SGTUMesh::HEXA8_FACE_PAIRS,MEDCoupling1SGTUMesh::HEXA8_FACE_PAIRS+6,oldAxis))); + std::size_t pos0(pos/2),pos1(pos%2); + int oldAxisOpp(MEDCoupling1SGTUMesh::HEXA8_FACE_PAIRS[2*pos0+(pos1+1)%2]); + mcIdType oldConn[8],myConn2[8]={-1,-1,-1,-1,-1,-1,-1,-1},myConn[8],edgeConn[2],allFacesTmp[24],neighTmp[6]; + oldConn[0]=allFacesNodalConn[0]; oldConn[1]=allFacesNodalConn[1]; oldConn[2]=allFacesNodalConn[2]; oldConn[3]=allFacesNodalConn[3]; + oldConn[4]=allFacesNodalConn[4]; oldConn[5]=allFacesNodalConn[7]; oldConn[6]=allFacesNodalConn[6]; oldConn[7]=allFacesNodalConn[5]; + const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel(INTERP_KERNEL::NORM_HEXA8)); + for(int i=0;i<4;i++) + myConn2[i]=validConnQuad4NeighSide[(4-i+TAB2[validAxis])%4]; + for(int i=0;i<4;i++) + { + mcIdType nodeId(myConn2[i]);//the node id for which the opposite one will be found + bool found(false); + INTERP_KERNEL::NormalizedCellType typeOfSon; + for(int j=0;j<12 && !found;j++) + { + cm.fillSonEdgesNodalConnectivity3D(j,oldConn,-1,edgeConn,typeOfSon); + if(edgeConn[0]==nodeId || edgeConn[1]==nodeId) + { + if(std::find(allFacesNodalConn+4*oldAxisOpp,allFacesNodalConn+4*oldAxisOpp+4,edgeConn[0]==nodeId?edgeConn[1]:edgeConn[0])!=allFacesNodalConn+4*oldAxisOpp+4) + { + myConn2[i+4]=edgeConn[0]==nodeId?edgeConn[1]:edgeConn[0]; + found=true; + } + } + } + if(!found) + throw INTERP_KERNEL::Exception("UpdateHexa8Cell : Internal Error !"); + } + const int *myTab(TAB+8*validAxis); + for(int i=0;i<8;i++) + myConn[i]=myConn2[myTab[i]]; + for(int i=0;i<6;i++) + { + cm.fillSonCellNodalConnectivity(i,myConn,allFacesTmp+4*i); + std::set s(allFacesTmp+4*i,allFacesTmp+4*i+4); + bool found(false); + for(int j=0;j<6 && !found;j++) + { + std::set s1(allFacesNodalConn+4*j,allFacesNodalConn+4*j+4); + if(s==s1) + { + neighTmp[i]=myNeighbours[j]; + found=true; + } + } + if(!found) + throw INTERP_KERNEL::Exception("UpdateHexa8Cell : Internal Error #2 !"); + } + std::copy(allFacesTmp,allFacesTmp+24,allFacesNodalConn); + std::copy(neighTmp,neighTmp+6,myNeighbours); + return false; +} + +/// @endcond + +/*! + * This method expects the \a this contains NORM_HEXA8 cells only. This method will sort each cells in \a this so that their numbering was + * homogeneous. If it succeeds the result of MEDCouplingUMesh::tetrahedrize will return a conform mesh. + * + * \return DataArrayIdType * - a newly allocated array (to be managed by the caller) containing renumbered cell ids. + * + * \throw If \a this is not a mesh containing only NORM_HEXA8 cells. + * \throw If \a this is not properly allocated. + * \sa MEDCouplingUMesh::tetrahedrize, MEDCouplingUMesh::simplexize. + */ +DataArrayIdType *MEDCoupling1SGTUMesh::sortHexa8EachOther() +{ + MCAuto quads(explodeEachHexa8To6Quad4());//checks that only hexa8 + mcIdType nbHexa8=getNumberOfCells(); + mcIdType *cQuads(quads->getNodalConnectivity()->getPointer()); + MCAuto neighOfQuads(DataArrayIdType::New()); neighOfQuads->alloc(nbHexa8*6,1); neighOfQuads->fillWithValue(-1); + mcIdType *ptNeigh(neighOfQuads->getPointer()); + {//neighOfQuads tells for each face of each Quad8 which cell (if!=-1) is connected to this face. + MCAuto quadsTmp(quads->buildUnstructured()); + MCAuto ccSafe,cciSafe; + DataArrayIdType *cc(0),*cci(0); + quadsTmp->findCommonCells(3,0,cc,cci); + ccSafe=cc; cciSafe=cci; + const mcIdType *ccPtr(ccSafe->begin()); + mcIdType nbOfPair=cci->getNumberOfTuples()-1; + for(mcIdType i=0;i ret(DataArrayIdType::New()); ret->alloc(0,1); + std::vector fetched(nbHexa8,false); + std::vector::iterator it(std::find(fetched.begin(),fetched.end(),false)); + while(it!=fetched.end())//it will turns as time as number of connected zones + { + mcIdType cellId(ToIdType(std::distance(fetched.begin(),it)));//it is the seed of the connected zone. + std::set s; s.insert(cellId);//s contains already organized. + while(!s.empty()) + { + std::set sNext; + for(std::set::const_iterator it0=s.begin();it0!=s.end();it0++) + { + fetched[*it0]=true; + mcIdType *myNeighb(ptNeigh+6*(*it0)); + for(int i=0;i<6;i++) + { + if(myNeighb[i]!=-1 && !fetched[myNeighb[i]]) + { + std::size_t pos(std::distance(HEXA8_FACE_PAIRS,std::find(HEXA8_FACE_PAIRS,HEXA8_FACE_PAIRS+6,i))); + std::size_t pos0(pos/2),pos1(pos%2); + if(!UpdateHexa8Cell(HEXA8_FACE_PAIRS[2*pos0+(pos1+1)%2],*it0,cQuads+6*4*(*it0)+4*i,cQuads+6*4*myNeighb[i],ptNeigh+6*myNeighb[i])) + ret->pushBackSilent(myNeighb[i]); + fetched[myNeighb[i]]=true; + sNext.insert(myNeighb[i]); + } + } + } + s=sNext; + } + it=std::find(fetched.begin(),fetched.end(),false); + } + if(!ret->empty()) + { + mcIdType *conn(getNodalConnectivity()->getPointer()); + for(const mcIdType *pt=ret->begin();pt!=ret->end();pt++) + { + mcIdType cellId(*pt); + conn[8*cellId+0]=cQuads[24*cellId+0]; conn[8*cellId+1]=cQuads[24*cellId+1]; conn[8*cellId+2]=cQuads[24*cellId+2]; conn[8*cellId+3]=cQuads[24*cellId+3]; + conn[8*cellId+4]=cQuads[24*cellId+4]; conn[8*cellId+5]=cQuads[24*cellId+7]; conn[8*cellId+6]=cQuads[24*cellId+6]; conn[8*cellId+7]=cQuads[24*cellId+5]; + } + declareAsNew(); + } + return ret.retn(); +} + +MEDCoupling1DGTUMesh *MEDCoupling1SGTUMesh::computeDualMesh3D() const +{ + static const int DUAL_TETRA_0[36]={ + 4,1,0, 6,0,3, 7,3,1, + 4,0,1, 5,2,0, 8,1,2, + 6,3,0, 5,0,2, 9,2,3, + 7,1,3, 9,3,2, 8,2,1 + }; + static const int DUAL_TETRA_1[36]={ + 8,4,10, 11,5,8, 10,7,11, + 9,4,8, 8,5,12, 12,6,9, + 10,4,9, 9,6,13, 13,7,10, + 12,5,11, 13,6,12, 11,7,13 + }; + static const int FACEID_NOT_SH_NODE[4]={2,3,1,0}; + if(getCellModelEnum()!=INTERP_KERNEL::NORM_TETRA4) + throw INTERP_KERNEL::Exception("MEDCoupling1SGTUMesh::computeDualMesh3D : only TETRA4 supported !"); + checkFullyDefined(); + MCAuto thisu(buildUnstructured()); + MCAuto revNodArr(DataArrayIdType::New()),revNodIArr(DataArrayIdType::New()); + thisu->getReverseNodalConnectivity(revNodArr,revNodIArr); + const mcIdType *revNod(revNodArr->begin()),*revNodI(revNodIArr->begin()),*nodal(_conn->begin()); + MCAuto d1Arr(DataArrayIdType::New()),di1Arr(DataArrayIdType::New()),rd1Arr(DataArrayIdType::New()),rdi1Arr(DataArrayIdType::New()); + MCAuto edges(thisu->explode3DMeshTo1D(d1Arr,di1Arr,rd1Arr,rdi1Arr)); + const mcIdType *d1(d1Arr->begin()); + MCAuto d2Arr(DataArrayIdType::New()),di2Arr(DataArrayIdType::New()),rd2Arr(DataArrayIdType::New()),rdi2Arr(DataArrayIdType::New()); + MCAuto faces(thisu->buildDescendingConnectivity(d2Arr,di2Arr,rd2Arr,rdi2Arr)); thisu=0; + const mcIdType *d2(d2Arr->begin()),*rdi2(rdi2Arr->begin()); + MCAuto edgesBaryArr(edges->computeCellCenterOfMass()),facesBaryArr(faces->computeCellCenterOfMass()),baryArr(computeCellCenterOfMass()); + const mcIdType nbOfNodes(getNumberOfNodes()); + const mcIdType offset0=nbOfNodes+faces->getNumberOfCells(); + const mcIdType offset1=offset0+edges->getNumberOfCells(); + edges=0; faces=0; + std::vector v(4); v[0]=getCoords(); v[1]=facesBaryArr; v[2]=edgesBaryArr; v[3]=baryArr; + MCAuto zeArr(DataArrayDouble::Aggregate(v)); baryArr=0; edgesBaryArr=0; facesBaryArr=0; + std::string name("DualOf_"); name+=getName(); + MCAuto ret(MEDCoupling1DGTUMesh::New(name,INTERP_KERNEL::NORM_POLYHED)); ret->setCoords(zeArr); + MCAuto cArr(DataArrayIdType::New()),ciArr(DataArrayIdType::New()); ciArr->alloc(nbOfNodes+1,1); ciArr->setIJ(0,0,0); cArr->alloc(0,1); + for(mcIdType i=0;ipushBackSilent(-1); + mcIdType tmp[14]; + // + tmp[0]=d1[6*curCellId+DUAL_TETRA_0[nodePosInCurCell*9+0]-4]+offset0; tmp[1]=d2[4*curCellId+DUAL_TETRA_0[nodePosInCurCell*9+1]]+nbOfNodes; + tmp[2]=curCellId+offset1; tmp[3]=d2[4*curCellId+DUAL_TETRA_0[nodePosInCurCell*9+2]]+nbOfNodes; + tmp[4]=-1; + tmp[5]=d1[6*curCellId+DUAL_TETRA_0[nodePosInCurCell*9+3]-4]+offset0; tmp[6]=d2[4*curCellId+DUAL_TETRA_0[nodePosInCurCell*9+4]]+nbOfNodes; + tmp[7]=curCellId+offset1; tmp[8]=d2[4*curCellId+DUAL_TETRA_0[nodePosInCurCell*9+5]]+nbOfNodes; + tmp[9]=-1; + tmp[10]=d1[6*curCellId+DUAL_TETRA_0[nodePosInCurCell*9+6]-4]+offset0; tmp[11]=d2[4*curCellId+DUAL_TETRA_0[nodePosInCurCell*9+7]]+nbOfNodes; + tmp[12]=curCellId+offset1; tmp[13]=d2[4*curCellId+DUAL_TETRA_0[nodePosInCurCell*9+8]]+nbOfNodes; + cArr->insertAtTheEnd(tmp,tmp+14); + int kk(0); + for(int k=0;k<4;k++) + { + if(FACEID_NOT_SH_NODE[nodePosInCurCell]!=k) + { + const mcIdType *faceId(d2+4*curCellId+k); + if(rdi2[*faceId+1]-rdi2[*faceId]==1) + { + mcIdType tmp2[5]; tmp2[0]=-1; tmp2[1]=i; + tmp2[2]=d1[6*curCellId+DUAL_TETRA_1[9*nodePosInCurCell+3*kk+0]-8]+offset0; + tmp2[3]=d2[4*curCellId+DUAL_TETRA_1[9*nodePosInCurCell+3*kk+1]-4]+nbOfNodes; + tmp2[4]=d1[6*curCellId+DUAL_TETRA_1[9*nodePosInCurCell+3*kk+2]-8]+offset0; + cArr->insertAtTheEnd(tmp2,tmp2+5); + } + kk++; + } + } + } + ciArr->setIJ(i+1,0,cArr->getNumberOfTuples()); + } + ret->setNodalConnectivity(cArr,ciArr); + return ret.retn(); +} + +MEDCoupling1DGTUMesh *MEDCoupling1SGTUMesh::computeDualMesh2D() const +{ + static const int DUAL_TRI_0[6]={0,2, 1,0, 2,1}; + static const int DUAL_TRI_1[6]={-3,+5, +3,-4, +4,-5}; + static const int FACEID_NOT_SH_NODE[3]={1,2,0}; + if(getCellModelEnum()!=INTERP_KERNEL::NORM_TRI3) + throw INTERP_KERNEL::Exception("MEDCoupling1SGTUMesh::computeDualMesh2D : only TRI3 supported !"); + checkFullyDefined(); + MCAuto thisu(buildUnstructured()); + MCAuto revNodArr(DataArrayIdType::New()),revNodIArr(DataArrayIdType::New()); + thisu->getReverseNodalConnectivity(revNodArr,revNodIArr); + const mcIdType *revNod(revNodArr->begin()),*revNodI(revNodIArr->begin()),*nodal(_conn->begin()); + MCAuto d2Arr(DataArrayIdType::New()),di2Arr(DataArrayIdType::New()),rd2Arr(DataArrayIdType::New()),rdi2Arr(DataArrayIdType::New()); + MCAuto edges(thisu->buildDescendingConnectivity(d2Arr,di2Arr,rd2Arr,rdi2Arr)); thisu=0; + const mcIdType *d2(d2Arr->begin()),*rdi2(rdi2Arr->begin()); + MCAuto edgesBaryArr(edges->computeCellCenterOfMass()),baryArr(computeCellCenterOfMass()); + const mcIdType nbOfNodes(getNumberOfNodes()),offset0(nbOfNodes+edges->getNumberOfCells()); + edges=0; + std::vector v(3); v[0]=getCoords(); v[1]=edgesBaryArr; v[2]=baryArr; + MCAuto zeArr(DataArrayDouble::Aggregate(v)); baryArr=0; edgesBaryArr=0; + std::string name("DualOf_"); name+=getName(); + MCAuto ret(MEDCoupling1DGTUMesh::New(name,INTERP_KERNEL::NORM_POLYGON)); ret->setCoords(zeArr); + MCAuto cArr(DataArrayIdType::New()),ciArr(DataArrayIdType::New()); ciArr->alloc(nbOfNodes+1,1); ciArr->setIJ(0,0,0); cArr->alloc(0,1); + for(mcIdType i=0;i > polyg; + for(int j=0;j locV(3); + locV[0]=d2[3*curCellId+DUAL_TRI_0[2*nodePosInCurCell+0]]+nbOfNodes; locV[1]=curCellId+offset0; locV[2]=d2[3*curCellId+DUAL_TRI_0[2*nodePosInCurCell+1]]+nbOfNodes; + polyg.push_back(locV); + int kk(0); + for(int k=0;k<3;k++) + { + if(FACEID_NOT_SH_NODE[nodePosInCurCell]!=k) + { + const mcIdType *edgeId(d2+3*curCellId+k); + if(rdi2[*edgeId+1]-rdi2[*edgeId]==1) + { + std::vector locV2(2); + int zeLocEdgeIdRel(DUAL_TRI_1[2*nodePosInCurCell+kk]); + if(zeLocEdgeIdRel>0) + { locV2[0]=d2[3*curCellId+zeLocEdgeIdRel-3]+nbOfNodes; locV2[1]=i; } + else + { locV2[0]=i; locV2[1]=d2[3*curCellId-zeLocEdgeIdRel-3]+nbOfNodes; } + polyg.push_back(locV2); + } + kk++; + } + } + } + std::vector zePolyg(MEDCoupling1DGTUMesh::BuildAPolygonFromParts(polyg)); + cArr->insertAtTheEnd(zePolyg.begin(),zePolyg.end()); + ciArr->setIJ(i+1,0,cArr->getNumberOfTuples()); + } + ret->setNodalConnectivity(cArr,ciArr); + return ret.retn(); +} + +/*! + * This method aggregate the bbox of each cell and put it into bbox + * + * \param [in] arcDetEps - a parameter specifying in case of 2D quadratic polygon cell the detection limit between linear and arc circle. (By default 1e-12) + * For all other cases this input parameter is ignored. + * \return DataArrayDouble * - newly created object (to be managed by the caller) \a this number of cells tuples and 2*spacedim components. + * + * \throw If \a this is not fully set (coordinates and connectivity). + * \throw If a cell in \a this has no valid nodeId. + */ +DataArrayDouble *MEDCoupling1SGTUMesh::getBoundingBoxForBBTree(double arcDetEps) const +{ + mcIdType spaceDim(getSpaceDimension()),nbOfCells(getNumberOfCells()),nbOfNodes(getNumberOfNodes()),nbOfNodesPerCell(getNumberOfNodesPerCell()); + MCAuto ret(DataArrayDouble::New()); ret->alloc(nbOfCells,2*spaceDim); + double *bbox(ret->getPointer()); + for(mcIdType i=0;i::max(); + bbox[2*i+1]=-std::numeric_limits::max(); + } + const double *coordsPtr(_coords->getConstPointer()); + const mcIdType *conn(_conn->getConstPointer()); + for(mcIdType i=0;i=0 && nodeId ret(MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME)); + mcIdType nbCells=getNumberOfCells(); + MCAuto arr(DataArrayDouble::New()); + arr->alloc(nbCells,1); + INTERP_KERNEL::AutoCppPtr dc(_cm->buildInstanceOfDiameterCalulator(getSpaceDimension())); + dc->computeFor1SGTUMeshFrmt(nbCells,_conn->begin(),getCoords()->begin(),arr->getPointer()); + ret->setMesh(this); + ret->setArray(arr); + ret->setName("Diameter"); + return ret.retn(); +} + +/*! + * 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 MEDCoupling1SGTUMesh::invertOrientationOfAllCells() +{ + checkConsistencyOfConnectivity(); + INTERP_KERNEL::AutoCppPtr oi(INTERP_KERNEL::OrientationInverter::BuildInstanceFrom(getCellModelEnum())); + mcIdType nbOfNodesPerCell=ToIdType(_cm->getNumberOfNodes()),nbCells=getNumberOfCells(); + mcIdType *conn(_conn->getPointer()); + for(mcIdType i=0;ioperate(conn+i*nbOfNodesPerCell,conn+(i+1)*nbOfNodesPerCell); + updateTime(); +} + //== -MEDCoupling1DGTUMesh *MEDCoupling1DGTUMesh::New(const char *name, INTERP_KERNEL::NormalizedCellType type) throw(INTERP_KERNEL::Exception) +MEDCoupling1DGTUMesh *MEDCoupling1DGTUMesh::New() +{ + return new MEDCoupling1DGTUMesh; +} + +MEDCoupling1DGTUMesh *MEDCoupling1DGTUMesh::New(const std::string& name, INTERP_KERNEL::NormalizedCellType type) { if(type==INTERP_KERNEL::NORM_ERROR) throw INTERP_KERNEL::Exception("MEDCoupling1DGTUMesh::New : NORM_ERROR is not a valid type to be used as base geometric type for a mesh !"); @@ -1513,20 +2183,24 @@ MEDCoupling1DGTUMesh *MEDCoupling1DGTUMesh::New(const char *name, INTERP_KERNEL: return new MEDCoupling1DGTUMesh(name,cm); } -MEDCoupling1DGTUMesh::MEDCoupling1DGTUMesh(const char *name, const INTERP_KERNEL::CellModel& cm):MEDCoupling1GTUMesh(name,cm) +MEDCoupling1DGTUMesh::MEDCoupling1DGTUMesh() { } -MEDCoupling1DGTUMesh::MEDCoupling1DGTUMesh(const MEDCoupling1DGTUMesh& other, bool recDeepCpy):MEDCoupling1GTUMesh(other,recDeepCpy),_conn(other._conn) +MEDCoupling1DGTUMesh::MEDCoupling1DGTUMesh(const std::string& name, const INTERP_KERNEL::CellModel& cm):MEDCoupling1GTUMesh(name,cm) +{ +} + +MEDCoupling1DGTUMesh::MEDCoupling1DGTUMesh(const MEDCoupling1DGTUMesh& other, bool recDeepCpy):MEDCoupling1GTUMesh(other,recDeepCpy),_conn_indx(other._conn_indx),_conn(other._conn) { if(recDeepCpy) { - const DataArrayInt *c(other._conn); + const DataArrayIdType *c(other._conn); if(c) - _conn=c->deepCpy(); + _conn=c->deepCopy(); c=other._conn_indx; if(c) - _conn_indx=c->deepCpy(); + _conn_indx=c->deepCopy(); } } @@ -1536,17 +2210,17 @@ MEDCoupling1DGTUMesh *MEDCoupling1DGTUMesh::clone(bool recDeepCpy) const } /*! - * This method behaves mostly like MEDCoupling1DGTUMesh::deepCpy method, except that only nodal connectivity arrays are deeply copied. + * This method behaves mostly like MEDCoupling1DGTUMesh::deepCopy method, except that only nodal connectivity arrays are deeply copied. * The coordinates are shared between \a this and the returned instance. * - * \return MEDCouplingUMesh * - A new object instance holding the copy of \a this (deep for connectivity, shallow for coordiantes) - * \sa MEDCoupling1DGTUMesh::deepCpy + * \return MEDCoupling1DGTUMesh * - A new object instance holding the copy of \a this (deep for connectivity, shallow for coordiantes) + * \sa MEDCoupling1DGTUMesh::deepCopy */ -MEDCouplingPointSet *MEDCoupling1DGTUMesh::deepCpyConnectivityOnly() const throw(INTERP_KERNEL::Exception) +MEDCoupling1DGTUMesh *MEDCoupling1DGTUMesh::deepCopyConnectivityOnly() const { - checkCoherency(); - MEDCouplingAutoRefCountObjectPtr ret(clone(false)); - MEDCouplingAutoRefCountObjectPtr c(_conn->deepCpy()),ci(_conn_indx->deepCpy()); + checkConsistencyLight(); + MCAuto ret(clone(false)); + MCAuto c(_conn->deepCopy()),ci(_conn_indx->deepCopy()); ret->setNodalConnectivity(c,ci); return ret.retn(); } @@ -1554,7 +2228,7 @@ MEDCouplingPointSet *MEDCoupling1DGTUMesh::deepCpyConnectivityOnly() const throw void MEDCoupling1DGTUMesh::updateTime() const { MEDCoupling1GTUMesh::updateTime(); - const DataArrayInt *c(_conn); + const DataArrayIdType *c(_conn); if(c) updateTimeWith(*c); c=_conn_indx; @@ -1562,24 +2236,25 @@ void MEDCoupling1DGTUMesh::updateTime() const updateTimeWith(*c); } -std::size_t MEDCoupling1DGTUMesh::getHeapMemorySize() const +std::size_t MEDCoupling1DGTUMesh::getHeapMemorySizeWithoutChildren() const { - std::size_t ret=0; - const DataArrayInt *c(_conn); - if(c) - ret+=c->getHeapMemorySize(); - c=_conn_indx; - if(c) - ret+=c->getHeapMemorySize(); - return MEDCoupling1GTUMesh::getHeapMemorySize()+ret; + return MEDCoupling1GTUMesh::getHeapMemorySizeWithoutChildren(); } -MEDCouplingMesh *MEDCoupling1DGTUMesh::deepCpy() const +std::vector MEDCoupling1DGTUMesh::getDirectChildrenWithNull() const +{ + std::vector ret(MEDCoupling1GTUMesh::getDirectChildrenWithNull()); + ret.push_back((const DataArrayIdType *)_conn); + ret.push_back((const DataArrayIdType *)_conn_indx); + return ret; +} + +MEDCoupling1DGTUMesh *MEDCoupling1DGTUMesh::deepCopy() const { return clone(true); } -bool MEDCoupling1DGTUMesh::isEqualIfNotWhy(const MEDCouplingMesh *other, double prec, std::string& reason) const throw(INTERP_KERNEL::Exception) +bool MEDCoupling1DGTUMesh::isEqualIfNotWhy(const MEDCouplingMesh *other, double prec, std::string& reason) const { if(!other) throw INTERP_KERNEL::Exception("MEDCoupling1DGTUMesh::isEqualIfNotWhy : input other pointer is null !"); @@ -1592,7 +2267,7 @@ bool MEDCoupling1DGTUMesh::isEqualIfNotWhy(const MEDCouplingMesh *other, double } if(!MEDCoupling1GTUMesh::isEqualIfNotWhy(other,prec,reason)) return false; - const DataArrayInt *c1(_conn),*c2(otherC->_conn); + const DataArrayIdType *c1(_conn),*c2(otherC->_conn); if(c1==c2) return true; if(!c1 || !c2) @@ -1602,7 +2277,7 @@ bool MEDCoupling1DGTUMesh::isEqualIfNotWhy(const MEDCouplingMesh *other, double } if(!c1->isEqualIfNotWhy(*c2,reason)) { - reason.insert(0,"Nodal connectivity DataArrayInt differs : "); + reason.insert(0,"Nodal connectivity DataArrayIdType differs : "); return false; } c1=_conn_indx; c2=otherC->_conn_indx; @@ -1615,7 +2290,7 @@ bool MEDCoupling1DGTUMesh::isEqualIfNotWhy(const MEDCouplingMesh *other, double } if(!c1->isEqualIfNotWhy(*c2,reason)) { - reason.insert(0,"Nodal connectivity index DataArrayInt differs : "); + reason.insert(0,"Nodal connectivity index DataArrayIdType differs : "); return false; } return true; @@ -1630,15 +2305,7 @@ bool MEDCoupling1DGTUMesh::isEqualWithoutConsideringStr(const MEDCouplingMesh *o return false; if(!MEDCoupling1GTUMesh::isEqualWithoutConsideringStr(other,prec)) return false; - const DataArrayInt *c1(_conn),*c2(otherC->_conn); - if(c1==c2) - return true; - if(!c1 || !c2) - return false; - if(!c1->isEqualWithoutConsideringStr(*c2)) - return false; - return true; - c1=_conn_indx; c2=otherC->_conn_indx; + const DataArrayIdType *c1(_conn),*c2(otherC->_conn); if(c1==c2) return true; if(!c1 || !c2) @@ -1658,13 +2325,13 @@ bool MEDCoupling1DGTUMesh::isEqualWithoutConsideringStr(const MEDCouplingMesh *o * \param [in] prec - the precision used to compare nodes of the two meshes. * \throw If the two meshes do not match. */ -void MEDCoupling1DGTUMesh::checkFastEquivalWith(const MEDCouplingMesh *other, double prec) const throw(INTERP_KERNEL::Exception) +void MEDCoupling1DGTUMesh::checkFastEquivalWith(const MEDCouplingMesh *other, double prec) const { MEDCouplingPointSet::checkFastEquivalWith(other,prec); const MEDCoupling1DGTUMesh *otherC=dynamic_cast(other); if(!otherC) throw INTERP_KERNEL::Exception("MEDCoupling1DGTUMesh::checkFastEquivalWith : Two meshes are not unstructured with single dynamic geometric type !"); - const DataArrayInt *c1(_conn),*c2(otherC->_conn); + const DataArrayIdType *c1(_conn),*c2(otherC->_conn); if(c1!=c2) { if(!c1 || !c2) @@ -1690,9 +2357,9 @@ void MEDCoupling1DGTUMesh::checkFastEquivalWith(const MEDCouplingMesh *other, do } } -void MEDCoupling1DGTUMesh::checkCoherencyOfConnectivity() const throw(INTERP_KERNEL::Exception) +void MEDCoupling1DGTUMesh::checkConsistencyOfConnectivity() const { - const DataArrayInt *c1(_conn); + const DataArrayIdType *c1(_conn); if(c1) { if(c1->getNumberOfComponents()!=1) @@ -1704,7 +2371,7 @@ void MEDCoupling1DGTUMesh::checkCoherencyOfConnectivity() const throw(INTERP_KER else throw INTERP_KERNEL::Exception("Nodal connectivity array not defined !"); // - int sz2=_conn->getNumberOfTuples(); + mcIdType sz2(_conn->getNumberOfTuples()); c1=_conn_indx; if(c1) { @@ -1715,8 +2382,8 @@ void MEDCoupling1DGTUMesh::checkCoherencyOfConnectivity() const throw(INTERP_KER throw INTERP_KERNEL::Exception("Nodal connectivity index array is expected to have a a size of 1 at least !"); if(c1->getInfoOnComponent(0)!="") throw INTERP_KERNEL::Exception("Nodal connectivity index array is expected to have no info on its single component !"); - int f=c1->front(),ll=c1->back(); - if(f<0 || f>=sz2) + mcIdType f=c1->front(),ll=c1->back(); + if(f<0 || (sz2>0 && f>=sz2)) { std::ostringstream oss; oss << "Nodal connectivity index array first value (" << f << ") is expected to be exactly in [0," << sz2 << ") !"; throw INTERP_KERNEL::Exception(oss.str().c_str()); @@ -1734,10 +2401,10 @@ void MEDCoupling1DGTUMesh::checkCoherencyOfConnectivity() const throw(INTERP_KER } else throw INTERP_KERNEL::Exception("Nodal connectivity index array not defined !"); - int szOfC1Exp=_conn_indx->back(); + mcIdType szOfC1Exp=_conn_indx->back(); if(sz2getNumberOfTuples() << " !"; + std::ostringstream oss; oss << "MEDCoupling1DGTUMesh::checkConsistencyOfConnectivity : The expected length of nodal connectivity array regarding index is " << szOfC1Exp << " but the actual size of it is " << c1->getNumberOfTuples() << " !"; throw INTERP_KERNEL::Exception(oss.str().c_str()); } } @@ -1747,23 +2414,23 @@ void MEDCoupling1DGTUMesh::checkCoherencyOfConnectivity() const throw(INTERP_KER * In addition you are sure that the length of nodal connectivity index array is bigger than or equal to one. * In addition you are also sure that length of nodal connectivity is coherent with the content of the last value in the index array. */ -void MEDCoupling1DGTUMesh::checkCoherency() const throw(INTERP_KERNEL::Exception) +void MEDCoupling1DGTUMesh::checkConsistencyLight() const { - MEDCouplingPointSet::checkCoherency(); - checkCoherencyOfConnectivity(); + MEDCouplingPointSet::checkConsistencyLight(); + checkConsistencyOfConnectivity(); } -void MEDCoupling1DGTUMesh::checkCoherency1(double eps) const throw(INTERP_KERNEL::Exception) +void MEDCoupling1DGTUMesh::checkConsistency(double eps) const { - checkCoherency(); - const DataArrayInt *c1(_conn),*c2(_conn_indx); + checkConsistencyLight(); + const DataArrayIdType *c1(_conn),*c2(_conn_indx); if(!c2->isMonotonic(true)) - throw INTERP_KERNEL::Exception("MEDCoupling1DGTUMesh::checkCoherency1 : the nodal connectivity index is expected to be increasing monotinic !"); + throw INTERP_KERNEL::Exception("MEDCoupling1DGTUMesh::checkConsistency : the nodal connectivity index is expected to be increasing monotinic !"); // - int nbOfTuples=c1->getNumberOfTuples(); - int nbOfNodes=getNumberOfNodes(); - const int *w(c1->begin()); - for(int i=0;igetNumberOfTuples()); + mcIdType nbOfNodes=getNumberOfNodes(); + const mcIdType *w(c1->begin()); + for(mcIdType i=0;i=nbOfNodes) @@ -1774,14 +2441,9 @@ void MEDCoupling1DGTUMesh::checkCoherency1(double eps) const throw(INTERP_KERNEL } } -void MEDCoupling1DGTUMesh::checkCoherency2(double eps) const throw(INTERP_KERNEL::Exception) +mcIdType MEDCoupling1DGTUMesh::getNumberOfCells() const { - checkCoherency1(eps); -} - -int MEDCoupling1DGTUMesh::getNumberOfCells() const -{ - checkCoherencyOfConnectivity();//do not remove + checkConsistencyOfConnectivity();//do not remove return _conn_indx->getNumberOfTuples()-1; } @@ -1793,20 +2455,20 @@ int MEDCoupling1DGTUMesh::getNumberOfCells() const * * \return a newly allocated array */ -DataArrayInt *MEDCoupling1DGTUMesh::computeNbOfNodesPerCell() const throw(INTERP_KERNEL::Exception) +DataArrayIdType *MEDCoupling1DGTUMesh::computeNbOfNodesPerCell() const { - checkCoherency(); + checkConsistencyLight(); _conn_indx->checkMonotonic(true); if(getCellModelEnum()!=INTERP_KERNEL::NORM_POLYHED) return _conn_indx->deltaShiftIndex(); // for polyhedrons - int nbOfCells=_conn_indx->getNumberOfTuples()-1; - MEDCouplingAutoRefCountObjectPtr ret=DataArrayInt::New(); + mcIdType nbOfCells=_conn_indx->getNumberOfTuples()-1; + MCAuto ret=DataArrayIdType::New(); ret->alloc(nbOfCells,1); - int *retPtr=ret->getPointer(); - const int *ci=_conn_indx->begin(),*c=_conn->begin(); - for(int i=0;igetPointer(); + const mcIdType *ci=_conn_indx->begin(),*c=_conn->begin(); + for(mcIdType i=0;icheckMonotonic(true); if(getCellModelEnum()!=INTERP_KERNEL::NORM_POLYHED && getCellModelEnum()!=INTERP_KERNEL::NORM_QPOLYG) return _conn_indx->deltaShiftIndex(); if(getCellModelEnum()==INTERP_KERNEL::NORM_QPOLYG) { - MEDCouplingAutoRefCountObjectPtr ret=_conn_indx->deltaShiftIndex(); + MCAuto ret=_conn_indx->deltaShiftIndex(); ret->applyDivideBy(2); return ret.retn(); } // for polyhedrons - int nbOfCells=_conn_indx->getNumberOfTuples()-1; - MEDCouplingAutoRefCountObjectPtr ret=DataArrayInt::New(); + mcIdType nbOfCells=_conn_indx->getNumberOfTuples()-1; + MCAuto ret=DataArrayIdType::New(); ret->alloc(nbOfCells,1); - int *retPtr=ret->getPointer(); - const int *ci=_conn_indx->begin(),*c=_conn->begin(); - for(int i=0;igetPointer(); + const mcIdType *ci=_conn_indx->begin(),*c=_conn->begin(); + for(mcIdType i=0;icheckMonotonic(true); - int nbOfCells(_conn_indx->getNumberOfTuples()-1); - MEDCouplingAutoRefCountObjectPtr ret=DataArrayInt::New(); + mcIdType nbOfCells=_conn_indx->getNumberOfTuples()-1; + MCAuto ret=DataArrayIdType::New(); ret->alloc(nbOfCells,1); - int *retPtr(ret->getPointer()); - const int *ci(_conn_indx->begin()),*c(_conn->begin()); + mcIdType *retPtr(ret->getPointer()); + const mcIdType *ci(_conn_indx->begin()),*c(_conn->begin()); if(getCellModelEnum()!=INTERP_KERNEL::NORM_POLYHED) { - for(int i=0;i s(c+ci[0],c+ci[1]); - *retPtr=(int)s.size(); + std::set s(c+ci[0],c+ci[1]); + *retPtr=ToIdType(s.size()); } } else { - for(int i=0;i s(c+ci[0],c+ci[1]); s.erase(-1); - *retPtr=(int)s.size(); + std::set s(c+ci[0],c+ci[1]); s.erase(-1); + *retPtr=ToIdType(s.size()); } } return ret.retn(); } -void MEDCoupling1DGTUMesh::getNodeIdsOfCell(int cellId, std::vector& conn) const +void MEDCoupling1DGTUMesh::getNodeIdsOfCell(mcIdType cellId, std::vector& conn) const { - int nbOfCells=getNumberOfCells();//performs checks - if(cellId>=0 && cellIdgetIJ(cellId,0),stp=_conn_indx->getIJ(cellId+1,0); - int nbOfNodes=stp-strt; + mcIdType strt=_conn_indx->getIJ(cellId,0),stp=_conn_indx->getIJ(cellId+1,0); + mcIdType nbOfNodes=stp-strt; if(nbOfNodes<0) throw INTERP_KERNEL::Exception("MEDCoupling1DGTUMesh::getNodeIdsOfCell : the index array is invalid ! Should be increasing monotonic !"); conn.resize(nbOfNodes); @@ -1888,7 +2550,23 @@ void MEDCoupling1DGTUMesh::getNodeIdsOfCell(int cellId, std::vector& conn) } else { - std::ostringstream oss; oss << "MEDCoupling1SGTUMesh::getNodeIdsOfCell : request for cellId #" << cellId << " must be in [0," << nbOfCells << ") !"; + std::ostringstream oss; oss << "MEDCoupling1DGTUMesh::getNodeIdsOfCell : request for cellId #" << cellId << " must be in [0," << nbOfCells << ") !"; + throw INTERP_KERNEL::Exception(oss.str().c_str()); + } +} + +mcIdType MEDCoupling1DGTUMesh::getNumberOfNodesInCell(mcIdType cellId) const +{ + mcIdType nbOfCells=getNumberOfCells();//performs checks + if(cellId>=0 && cellIdbegin()); + mcIdType strt=_conn_indx->getIJ(cellId,0),stp=_conn_indx->getIJ(cellId+1,0); + return stp-strt-ToIdType(std::count(conn+strt,conn+stp,-1)); + } + else + { + std::ostringstream oss; oss << "MEDCoupling1DGTUMesh::getNumberOfNodesInCell : request for cellId #" << cellId << " must be in [0," << nbOfCells << ") !"; throw INTERP_KERNEL::Exception(oss.str().c_str()); } } @@ -1896,6 +2574,8 @@ void MEDCoupling1DGTUMesh::getNodeIdsOfCell(int cellId, std::vector& conn) std::string MEDCoupling1DGTUMesh::simpleRepr() const { static const char msg0[]="No coordinates specified !"; + if(!_cm) + return std::string("Cell type not specified"); std::ostringstream ret; ret << "Single dynamic geometic type (" << _cm->getRepr() << ") unstructured mesh with name : \"" << getName() << "\"\n"; ret << "Description of mesh : \"" << getDescription() << "\"\n"; @@ -1921,11 +2601,11 @@ std::string MEDCoupling1DGTUMesh::simpleRepr() const ret << msg0 << "\n"; ret << "Number of cells : "; bool isOK=true; - try { checkCoherency(); } catch(INTERP_KERNEL::Exception& e) - { + try { checkConsistencyLight(); } catch(INTERP_KERNEL::Exception& /* e */) + { ret << "Nodal connectivity arrays are not set or badly set !\n"; isOK=false; - } + } if(isOK) ret << getNumberOfCells() << "\n"; ret << "Cell type : " << _cm->getRepr() << "\n"; @@ -1944,16 +2624,16 @@ std::string MEDCoupling1DGTUMesh::advancedRepr() const ret << "\n\nNodal Connectivity : \n____________________\n\n"; // bool isOK=true; - try { checkCoherency1(); } catch(INTERP_KERNEL::Exception& e) - { + try { checkConsistency(); } catch(INTERP_KERNEL::Exception& /* e */) + { ret << "Nodal connectivity arrays are not set or badly set !\n"; isOK=false; - } + } if(!isOK) return ret.str(); - int nbOfCells=getNumberOfCells(); - const int *ci=_conn_indx->begin(),*c=_conn->begin(); - for(int i=0;ibegin(),*c=_conn->begin(); + for(mcIdType i=0;i(ret," ")); @@ -1962,25 +2642,25 @@ std::string MEDCoupling1DGTUMesh::advancedRepr() const return ret.str(); } -DataArrayDouble *MEDCoupling1DGTUMesh::computeIsoBarycenterOfNodesPerCell() const throw(INTERP_KERNEL::Exception) +DataArrayDouble *MEDCoupling1DGTUMesh::computeIsoBarycenterOfNodesPerCell() const { - MEDCouplingAutoRefCountObjectPtr ret=DataArrayDouble::New(); + MCAuto ret=DataArrayDouble::New(); int spaceDim=getSpaceDimension(); - int nbOfCells=getNumberOfCells();//checkCoherency() - int nbOfNodes=getNumberOfNodes(); + mcIdType nbOfCells=getNumberOfCells();//checkConsistencyLight() + mcIdType nbOfNodes=getNumberOfNodes(); ret->alloc(nbOfCells,spaceDim); double *ptToFill=ret->getPointer(); const double *coor=_coords->begin(); - const int *nodal=_conn->begin(),*nodali=_conn_indx->begin(); + const mcIdType *nodal=_conn->begin(),*nodali=_conn_indx->begin(); nodal+=nodali[0]; if(getCellModelEnum()!=INTERP_KERNEL::NORM_POLYHED) { - for(int i=0;i= to avoid division by 0. { - for(int j=nodali[0];j=0 && *nodal()); @@ -1989,7 +2669,7 @@ DataArrayDouble *MEDCoupling1DGTUMesh::computeIsoBarycenterOfNodesPerCell() cons std::ostringstream oss; oss << "MEDCoupling1DGTUMesh::computeIsoBarycenterOfNodesPerCell : on cell #" << i << " presence of nodeId #" << *nodal << " should be in [0," << nbOfNodes << ") !"; throw INTERP_KERNEL::Exception(oss.str().c_str()); } - std::transform(ptToFill,ptToFill+spaceDim,ptToFill,std::bind2nd(std::multiplies(),1./(nodali[1]-nodali[0]))); + std::transform(ptToFill,ptToFill+spaceDim,ptToFill,std::bind(std::multiplies(),std::placeholders::_1,1./double(nodali[1]-nodali[0]))); } } else @@ -2001,13 +2681,13 @@ DataArrayDouble *MEDCoupling1DGTUMesh::computeIsoBarycenterOfNodesPerCell() cons } else { - for(int i=0;i= to avoid division by 0. { int nbOfNod=0; - for(int j=nodali[0];j=0 && *nodal(),1./nbOfNod)); + std::transform(ptToFill,ptToFill+spaceDim,ptToFill,std::bind(std::multiplies(),std::placeholders::_1,1./nbOfNod)); else { std::ostringstream oss; oss << "MEDCoupling1DGTUMesh::computeIsoBarycenterOfNodesPerCell (polyhedron) : no nodes in cell #" << i << " !"; @@ -2039,26 +2719,26 @@ DataArrayDouble *MEDCoupling1DGTUMesh::computeIsoBarycenterOfNodesPerCell() cons return ret.retn(); } -void MEDCoupling1DGTUMesh::renumberCells(const int *old2NewBg, bool check) throw(INTERP_KERNEL::Exception) +void MEDCoupling1DGTUMesh::renumberCells(const mcIdType *old2NewBg, bool check) { - int nbCells=getNumberOfCells(); - MEDCouplingAutoRefCountObjectPtr o2n=DataArrayInt::New(); - o2n->useArray(old2NewBg,false,C_DEALLOC,nbCells,1); + mcIdType nbCells=getNumberOfCells(); + MCAuto o2n=DataArrayIdType::New(); + o2n->useArray(old2NewBg,false,DeallocType::C_DEALLOC,nbCells,1); if(check) o2n=o2n->checkAndPreparePermutation(); // - const int *o2nPtr=o2n->getPointer(); - const int *conn=_conn->begin(),*conni=_conn_indx->begin(); - MEDCouplingAutoRefCountObjectPtr newConn=DataArrayInt::New(); - MEDCouplingAutoRefCountObjectPtr newConnI=DataArrayInt::New(); + const mcIdType *o2nPtr=o2n->getPointer(); + const mcIdType *conn=_conn->begin(),*conni=_conn_indx->begin(); + MCAuto newConn=DataArrayIdType::New(); + MCAuto newConnI=DataArrayIdType::New(); newConn->alloc(_conn->getNumberOfTuples(),1); newConnI->alloc(nbCells,1); newConn->copyStringInfoFrom(*_conn); newConnI->copyStringInfoFrom(*_conn_indx); // - int *newC=newConn->getPointer(),*newCI=newConnI->getPointer(); - for(int i=0;igetPointer(),*newCI=newConnI->getPointer(); + for(mcIdType i=0;i=0) newCI[newPos]=sz; else @@ -2067,12 +2747,11 @@ void MEDCoupling1DGTUMesh::renumberCells(const int *old2NewBg, bool check) throw throw INTERP_KERNEL::Exception(oss.str().c_str()); } } - newConnI->computeOffsets2(); newCI=newConnI->getPointer(); + newConnI->computeOffsetsFull(); newCI=newConnI->getPointer(); // - for(int i=0;i ret=MEDCouplingUMesh::New(getName().c_str(),getMeshDimension()); + MCAuto ret=MEDCouplingUMesh::New(getName(),getMeshDimension()); ret->setCoords(getCoords()); - const int *nodalConn=_conn->begin(),*nodalConnI=_conn_indx->begin(); - int nbCells=getNumberOfCells();//checkCoherency - int geoType=(int)getCellModelEnum(); - MEDCouplingAutoRefCountObjectPtr c=DataArrayInt::New(); c->alloc(nbCells+_conn->getNumberOfTuples(),1); - MEDCouplingAutoRefCountObjectPtr cI=DataArrayInt::New(); cI->alloc(nbCells+1); - int *cPtr=c->getPointer(),*ciPtr=cI->getPointer(); + const mcIdType *nodalConn=_conn->begin(),*nodalConnI=_conn_indx->begin(); + mcIdType nbCells=getNumberOfCells();//checkConsistencyLight + mcIdType geoType=ToIdType(getCellModelEnum()); + MCAuto c=DataArrayIdType::New(); c->alloc(nbCells+_conn->getNumberOfTuples(),1); + MCAuto cI=DataArrayIdType::New(); cI->alloc(nbCells+1); + mcIdType *cPtr=c->getPointer(),*ciPtr=cI->getPointer(); ciPtr[0]=0; - for(int i=0;i=0) { *cPtr++=geoType; @@ -2114,24 +2793,33 @@ MEDCouplingUMesh *MEDCoupling1DGTUMesh::buildUnstructured() const throw(INTERP_K } } ret->setConnectivity(c,cI,true); + try + { ret->copyTinyInfoFrom(this); } + catch(INTERP_KERNEL::Exception&) { } return ret.retn(); } /*! * Do nothing for the moment, because there is no policy that allows to split polygons, polyhedrons ... into simplexes */ -DataArrayInt *MEDCoupling1DGTUMesh::simplexize(int policy) throw(INTERP_KERNEL::Exception) +DataArrayIdType *MEDCoupling1DGTUMesh::simplexize(int policy) { - int nbOfCells=getNumberOfCells(); - MEDCouplingAutoRefCountObjectPtr ret=DataArrayInt::New(); + mcIdType nbOfCells=getNumberOfCells(); + MCAuto ret=DataArrayIdType::New(); ret->alloc(nbOfCells,1); ret->iota(0); return ret.retn(); } -void MEDCoupling1DGTUMesh::reprQuickOverview(std::ostream& stream) const throw(INTERP_KERNEL::Exception) +void MEDCoupling1DGTUMesh::reprQuickOverview(std::ostream& stream) const { - stream << "MEDCoupling1DGTUMesh C++ instance at " << this << ". Type=" << _cm->getRepr() << ". Name : \"" << getName() << "\"."; + stream << "MEDCoupling1DGTUMesh C++ instance at " << this << ". Type="; + if(!_cm) + { + stream << "Not defined"; + return ; + } + stream << _cm->getRepr() << ". Name : \"" << getName() << "\"."; stream << " Mesh dimension : " << getMeshDimension() << "."; if(!_coords) { stream << " No coordinates set !"; return ; } @@ -2140,16 +2828,16 @@ void MEDCoupling1DGTUMesh::reprQuickOverview(std::ostream& stream) const throw(I stream << " Space dimension : " << _coords->getNumberOfComponents() << "." << std::endl; stream << "Number of nodes : " << _coords->getNumberOfTuples() << "."; bool isOK=true; - try { checkCoherency(); } catch(INTERP_KERNEL::Exception& e) - { + try { checkConsistencyLight(); } catch(INTERP_KERNEL::Exception& /* e */) + { stream << std::endl << "Nodal connectivity NOT set properly !\n"; isOK=false; - } + } if(isOK) stream << std::endl << "Number of cells : " << getNumberOfCells() << "."; } -void MEDCoupling1DGTUMesh::shallowCopyConnectivityFrom(const MEDCouplingPointSet *other) throw(INTERP_KERNEL::Exception) +void MEDCoupling1DGTUMesh::shallowCopyConnectivityFrom(const MEDCouplingPointSet *other) { if(!other) throw INTERP_KERNEL::Exception("MEDCoupling1DGTUMesh::shallowCopyConnectivityFrom : input pointer is null !"); @@ -2172,67 +2860,67 @@ MEDCouplingPointSet *MEDCoupling1DGTUMesh::mergeMyselfWithOnSameCoords(const MED return Merge1DGTUMeshesOnSameCoords(ms); } -MEDCouplingPointSet *MEDCoupling1DGTUMesh::buildPartOfMySelfKeepCoords(const int *begin, const int *end) const +MEDCouplingPointSet *MEDCoupling1DGTUMesh::buildPartOfMySelfKeepCoords(const mcIdType *begin, const mcIdType *end) const { - checkCoherency(); - MEDCouplingAutoRefCountObjectPtr ret(new MEDCoupling1DGTUMesh(getName().c_str(),*_cm)); + checkConsistencyLight(); + MCAuto ret(new MEDCoupling1DGTUMesh(getName(),*_cm)); ret->setCoords(_coords); - DataArrayInt *c=0,*ci=0; - MEDCouplingUMesh::ExtractFromIndexedArrays(begin,end,_conn,_conn_indx,c,ci); - MEDCouplingAutoRefCountObjectPtr cSafe(c),ciSafe(ci); + DataArrayIdType *c=0,*ci=0; + DataArrayIdType::ExtractFromIndexedArrays(begin,end,_conn,_conn_indx,c,ci); + MCAuto cSafe(c),ciSafe(ci); ret->setNodalConnectivity(c,ci); return ret.retn(); } -MEDCouplingPointSet *MEDCoupling1DGTUMesh::buildPartOfMySelfKeepCoords2(int start, int end, int step) const +MEDCouplingPointSet *MEDCoupling1DGTUMesh::buildPartOfMySelfKeepCoordsSlice(mcIdType start, mcIdType end, mcIdType step) const { - checkCoherency(); - MEDCouplingAutoRefCountObjectPtr ret(new MEDCoupling1DGTUMesh(getName().c_str(),*_cm)); + checkConsistencyLight(); + MCAuto ret(new MEDCoupling1DGTUMesh(getName(),*_cm)); ret->setCoords(_coords); - DataArrayInt *c=0,*ci=0; - MEDCouplingUMesh::ExtractFromIndexedArrays2(start,end,step,_conn,_conn_indx,c,ci); - MEDCouplingAutoRefCountObjectPtr cSafe(c),ciSafe(ci); + DataArrayIdType *c=0,*ci=0; + DataArrayIdType::ExtractFromIndexedArraysSlice(start,end,step,_conn,_conn_indx,c,ci); + MCAuto cSafe(c),ciSafe(ci); ret->setNodalConnectivity(c,ci); return ret.retn(); } -void MEDCoupling1DGTUMesh::computeNodeIdsAlg(std::vector& nodeIdsInUse) const throw(INTERP_KERNEL::Exception) +void MEDCoupling1DGTUMesh::computeNodeIdsAlg(std::vector& nodeIdsInUse) const { - int sz((int)nodeIdsInUse.size()); - int nbCells(getNumberOfCells()); - const int *w(_conn->begin()),*wi(_conn_indx->begin()); - for(int i=0;ibegin();conn!=_conn->end();conn++) + { + if(*conn>=0 && *conn=0 && *ptbegin(),conn) << " value is " << *conn << " must be in [0," << sz << ") !"; throw INTERP_KERNEL::Exception(oss.str().c_str()); } } + } } -void MEDCoupling1DGTUMesh::getReverseNodalConnectivity(DataArrayInt *revNodal, DataArrayInt *revNodalIndx) const throw(INTERP_KERNEL::Exception) +void MEDCoupling1DGTUMesh::getReverseNodalConnectivity(DataArrayIdType *revNodal, DataArrayIdType *revNodalIndx) const { checkFullyDefined(); - int nbOfNodes=getNumberOfNodes(); - int *revNodalIndxPtr=(int *)malloc((nbOfNodes+1)*sizeof(int)); - revNodalIndx->useArray(revNodalIndxPtr,true,C_DEALLOC,nbOfNodes+1,1); + mcIdType nbOfNodes=getNumberOfNodes(); + mcIdType *revNodalIndxPtr=(mcIdType *)malloc((nbOfNodes+1)*sizeof(mcIdType)); + revNodalIndx->useArray(revNodalIndxPtr,true,DeallocType::C_DEALLOC,nbOfNodes+1,1); std::fill(revNodalIndxPtr,revNodalIndxPtr+nbOfNodes+1,0); - const int *conn=_conn->begin(),*conni=_conn_indx->begin(); - int nbOfCells=getNumberOfCells(); - int nbOfEltsInRevNodal=0; - for(int eltId=0;eltIdbegin(),*conni=_conn_indx->begin(); + mcIdType nbOfCells=getNumberOfCells(); + mcIdType nbOfEltsInRevNodal=0; + for(mcIdType eltId=0;eltId=0) { - for(int j=0;j=0 && nodeId()); + std::transform(revNodalIndxPtr+1,revNodalIndxPtr+nbOfNodes+1,revNodalIndxPtr,revNodalIndxPtr+1,std::plus()); conn=_conn->begin(); - int *revNodalPtr=(int *)malloc((nbOfEltsInRevNodal)*sizeof(int)); - revNodal->useArray(revNodalPtr,true,C_DEALLOC,nbOfEltsInRevNodal,1); + mcIdType *revNodalPtr=(mcIdType *)malloc((nbOfEltsInRevNodal)*sizeof(mcIdType)); + revNodal->useArray(revNodalPtr,true,DeallocType::C_DEALLOC,nbOfEltsInRevNodal,1); std::fill(revNodalPtr,revNodalPtr+nbOfEltsInRevNodal,-1); - for(int eltId=0;eltId(),-1))=eltId; + *std::find_if(revNodalPtr+revNodalIndxPtr[nodeId],revNodalPtr+revNodalIndxPtr[nodeId+1],std::bind(std::equal_to(),std::placeholders::_1,-1))=eltId; } } } -void MEDCoupling1DGTUMesh::checkFullyDefined() const throw(INTERP_KERNEL::Exception) +void MEDCoupling1DGTUMesh::checkFullyDefined() const { - if(!((const DataArrayInt *)_conn) || !((const DataArrayInt *)_conn_indx) || !((const DataArrayDouble *)_coords)) + if(!((const DataArrayIdType *)_conn) || !((const DataArrayIdType *)_conn_indx) || !((const DataArrayDouble *)_coords)) throw INTERP_KERNEL::Exception("MEDCoupling1DGTUMesh::checkFullyDefined : part of this is not fully defined."); } -bool MEDCoupling1DGTUMesh::isEmptyMesh(const std::vector& tinyInfo) const +bool MEDCoupling1DGTUMesh::isEmptyMesh(const std::vector& tinyInfo) const { throw INTERP_KERNEL::Exception("MEDCoupling1DGTUMesh::isEmptyMesh : not implemented yet !"); } +void MEDCoupling1DGTUMesh::getTinySerializationInformation(std::vector& tinyInfoD, std::vector& tinyInfo, std::vector& littleStrings) const +{ + int it,order; + double time=getTime(it,order); + tinyInfo.clear(); tinyInfoD.clear(); littleStrings.clear(); + // + littleStrings.push_back(getName()); + littleStrings.push_back(getDescription()); + littleStrings.push_back(getTimeUnit()); + // + std::vector littleStrings2,littleStrings3,littleStrings4; + if((const DataArrayDouble *)_coords) + _coords->getTinySerializationStrInformation(littleStrings2); + if((const DataArrayIdType *)_conn) + _conn->getTinySerializationStrInformation(littleStrings3); + if((const DataArrayIdType *)_conn_indx) + _conn_indx->getTinySerializationStrInformation(littleStrings4); + mcIdType sz0(ToIdType(littleStrings2.size())),sz1(ToIdType(littleStrings3.size())),sz2(ToIdType(littleStrings4.size())); + littleStrings.insert(littleStrings.end(),littleStrings2.begin(),littleStrings2.end()); + littleStrings.insert(littleStrings.end(),littleStrings3.begin(),littleStrings3.end()); + littleStrings.insert(littleStrings.end(),littleStrings4.begin(),littleStrings4.end()); + // + tinyInfo.push_back(getCellModelEnum()); + tinyInfo.push_back(it); + tinyInfo.push_back(order); + std::vector tinyInfo2,tinyInfo3,tinyInfo4; + if((const DataArrayDouble *)_coords) + _coords->getTinySerializationIntInformation(tinyInfo2); + if((const DataArrayIdType *)_conn) + _conn->getTinySerializationIntInformation(tinyInfo3); + if((const DataArrayIdType *)_conn_indx) + _conn_indx->getTinySerializationIntInformation(tinyInfo4); + mcIdType sz3(ToIdType(tinyInfo2.size())),sz4(ToIdType(tinyInfo3.size())),sz5(ToIdType(tinyInfo4.size())); + tinyInfo.push_back(sz0); tinyInfo.push_back(sz1); tinyInfo.push_back(sz2); tinyInfo.push_back(sz3); tinyInfo.push_back(sz4); tinyInfo.push_back(sz5); + tinyInfo.insert(tinyInfo.end(),tinyInfo2.begin(),tinyInfo2.end()); + tinyInfo.insert(tinyInfo.end(),tinyInfo3.begin(),tinyInfo3.end()); + tinyInfo.insert(tinyInfo.end(),tinyInfo4.begin(),tinyInfo4.end()); + // + tinyInfoD.push_back(time); +} + +void MEDCoupling1DGTUMesh::resizeForUnserialization(const std::vector& tinyInfo, DataArrayIdType *a1, DataArrayDouble *a2, std::vector& littleStrings) const +{ + std::vector tinyInfo2(tinyInfo.begin()+9,tinyInfo.begin()+9+tinyInfo[6]); + std::vector tinyInfo1(tinyInfo.begin()+9+tinyInfo[6],tinyInfo.begin()+9+tinyInfo[6]+tinyInfo[7]); + std::vector tinyInfo12(tinyInfo.begin()+9+tinyInfo[6]+tinyInfo[7],tinyInfo.begin()+9+tinyInfo[6]+tinyInfo[7]+tinyInfo[8]); + MCAuto p1(DataArrayIdType::New()); p1->resizeForUnserialization(tinyInfo1); + MCAuto p2(DataArrayIdType::New()); p2->resizeForUnserialization(tinyInfo12); + std::vector v(2); v[0]=p1; v[1]=p2; + p2=DataArrayIdType::Aggregate(v); + a2->resizeForUnserialization(tinyInfo2); + a1->alloc(p2->getNbOfElems(),1); +} + +void MEDCoupling1DGTUMesh::serialize(DataArrayIdType *&a1, DataArrayDouble *&a2) const +{ + mcIdType sz(0); + if((const DataArrayIdType *)_conn) + if(_conn->isAllocated()) + sz=_conn->getNbOfElems(); + if((const DataArrayIdType *)_conn_indx) + if(_conn_indx->isAllocated()) + sz+=_conn_indx->getNbOfElems(); + a1=DataArrayIdType::New(); + a1->alloc(sz,1); + mcIdType *work(a1->getPointer()); + if(sz!=0 && (const DataArrayIdType *)_conn) + work=std::copy(_conn->begin(),_conn->end(),a1->getPointer()); + if(sz!=0 && (const DataArrayIdType *)_conn_indx) + std::copy(_conn_indx->begin(),_conn_indx->end(),work); + sz=0; + if((const DataArrayDouble *)_coords) + if(_coords->isAllocated()) + sz=_coords->getNbOfElems(); + a2=DataArrayDouble::New(); + a2->alloc(sz,1); + if(sz!=0 && (const DataArrayDouble *)_coords) + std::copy(_coords->begin(),_coords->end(),a2->getPointer()); +} + +void MEDCoupling1DGTUMesh::unserialization(const std::vector& tinyInfoD, const std::vector& tinyInfo, const DataArrayIdType *a1, DataArrayDouble *a2, + const std::vector& littleStrings) +{ + INTERP_KERNEL::NormalizedCellType gt((INTERP_KERNEL::NormalizedCellType)tinyInfo[0]); + _cm=&INTERP_KERNEL::CellModel::GetCellModel(gt); + setName(littleStrings[0]); + setDescription(littleStrings[1]); + setTimeUnit(littleStrings[2]); + setTime(tinyInfoD[0],FromIdType(tinyInfo[1]),FromIdType(tinyInfo[2])); + mcIdType sz0(tinyInfo[3]),sz1(tinyInfo[4]),sz2(tinyInfo[5]),sz3(tinyInfo[6]),sz4(tinyInfo[7]),sz5(tinyInfo[8]); + // + _coords=DataArrayDouble::New(); + std::vector tinyInfo2(tinyInfo.begin()+9,tinyInfo.begin()+9+sz3); + _coords->resizeForUnserialization(tinyInfo2); + std::copy(a2->begin(),a2->end(),_coords->getPointer()); + _conn=DataArrayIdType::New(); + std::vector tinyInfo3(tinyInfo.begin()+9+sz3,tinyInfo.begin()+9+sz3+sz4); + _conn->resizeForUnserialization(tinyInfo3); + std::copy(a1->begin(),a1->begin()+_conn->getNbOfElems(),_conn->getPointer()); + _conn_indx=DataArrayIdType::New(); + std::vector tinyInfo4(tinyInfo.begin()+9+sz3+sz4,tinyInfo.begin()+9+sz3+sz4+sz5); + _conn_indx->resizeForUnserialization(tinyInfo4); + std::copy(a1->begin()+_conn->getNbOfElems(),a1->end(),_conn_indx->getPointer()); + std::vector littleStrings2(littleStrings.begin()+3,littleStrings.begin()+3+sz0); + _coords->finishUnserialization(tinyInfo2,littleStrings2); + std::vector littleStrings3(littleStrings.begin()+3+sz0,littleStrings.begin()+3+sz0+sz1); + _conn->finishUnserialization(tinyInfo3,littleStrings3); + std::vector littleStrings4(littleStrings.begin()+3+sz0+sz1,littleStrings.begin()+3+sz0+sz1+sz2); + _conn_indx->finishUnserialization(tinyInfo4,littleStrings4); +} + +/*! + * Finds nodes not used in any cell and returns an array giving a new id to every node + * by excluding the unused nodes, for which the array holds -1. The result array is + * a mapping in "Old to New" mode. + * \return DataArrayIdType * - a new instance of DataArrayIdType. Its length is \a + * this->getNumberOfNodes(). It holds for each node of \a this mesh either -1 + * if the node is unused or a new id else. The caller is to delete this + * array using decrRef() as it is no more needed. + * \throw If the coordinates array is not set. + * \throw If the nodal connectivity of cells is not defined. + * \throw If the nodal connectivity includes an invalid id. + * \sa MEDCoupling1DGTUMesh::getNodeIdsInUse, areAllNodesFetched + */ +DataArrayIdType *MEDCoupling1DGTUMesh::computeFetchedNodeIds() const +{ + checkConsistency(); + mcIdType nbNodes(getNumberOfNodes()); + std::vector fetchedNodes(nbNodes,false); + computeNodeIdsAlg(fetchedNodes); + mcIdType sz(ToIdType(std::count(fetchedNodes.begin(),fetchedNodes.end(),true))); + MCAuto ret(DataArrayIdType::New()); ret->alloc(sz,1); + mcIdType *retPtr(ret->getPointer()); + for(mcIdType i=0;igetNumberOfNodes(). It holds for each node of \a this mesh either -1 * if the node is unused or a new id else. The caller is to delete this * array using decrRef() as it is no more needed. * \throw If the coordinates array is not set. * \throw If the nodal connectivity of cells is not defined. * \throw If the nodal connectivity includes an invalid id. + * \sa MEDCoupling1DGTUMesh::computeFetchedNodeIds, areAllNodesFetched */ -DataArrayInt *MEDCoupling1DGTUMesh::getNodeIdsInUse(int& nbrOfNodesInUse) const throw(INTERP_KERNEL::Exception) +DataArrayIdType *MEDCoupling1DGTUMesh::getNodeIdsInUse(mcIdType& nbrOfNodesInUse) const { nbrOfNodesInUse=-1; - int nbOfNodes=getNumberOfNodes(); - int nbOfCells=getNumberOfCells();//checkCoherency - MEDCouplingAutoRefCountObjectPtr ret=DataArrayInt::New(); + mcIdType nbOfNodes=getNumberOfNodes(); + mcIdType nbOfCells=getNumberOfCells();//checkConsistencyLight + MCAuto ret=DataArrayIdType::New(); ret->alloc(nbOfNodes,1); - int *traducer=ret->getPointer(); + mcIdType *traducer=ret->getPointer(); std::fill(traducer,traducer+nbOfNodes,-1); - const int *conn=_conn->begin(),*conni(_conn_indx->begin()); - for(int i=0;ibegin(),*conni(_conn_indx->begin()); + for(mcIdType i=0;i=0 && nodeIdgetNumberOfTuples()); + mcIdType *pt(_conn->getPointer()); + for(mcIdType i=0;i& newNodeNumbersO2N) +{ + this->renumberNodesInConnT< INTERP_KERNEL::HashMap >(newNodeNumbersO2N); +} + +/*! + * Same than renumberNodesInConn(const mcIdType *) except that here the format of old-to-new traducer is using map instead + * of array. This method is dedicated for renumbering from a big set of nodes the a tiny set of nodes which is the case during extraction + * of a big mesh. + */ +void MEDCoupling1DGTUMesh::renumberNodesInConn(const std::map& newNodeNumbersO2N) +{ + this->renumberNodesInConnT< std::map >(newNodeNumbersO2N); +} + /*! * Changes ids of nodes within the nodal connectivity arrays according to a permutation * array in "Old to New" mode. The node coordinates array is \b not changed by this method. @@ -2331,17 +3202,16 @@ DataArrayInt *MEDCoupling1DGTUMesh::getNodeIdsInUse(int& nbrOfNodesInUse) const * \warning This method performs no check of validity of new ids. **Use it with care !** * \param [in] newNodeNumbersO2N - a permutation array, of length \a * this->getNumberOfNodes(), in "Old to New" mode. - * See \ref MEDCouplingArrayRenumbering for more info on renumbering modes. + * See \ref numbering for more info on renumbering modes. * \throw If the nodal connectivity of cells is not defined. */ -void MEDCoupling1DGTUMesh::renumberNodesInConn(const int *newNodeNumbersO2N) +void MEDCoupling1DGTUMesh::renumberNodesInConn(const mcIdType *newNodeNumbersO2N) { getNumberOfCells();//only to check that all is well defined. // - int nbElemsIn=getNumberOfNodes(); - int nbOfTuples=_conn->getNumberOfTuples(); - int *pt=_conn->getPointer(); - for(int i=0;igetNumberOfTuples()); + mcIdType *pt(_conn->getPointer()); + for(mcIdType i=0;i=0 && *ptdeclareAsNew(); // updateTime(); } @@ -2368,26 +3237,26 @@ void MEDCoupling1DGTUMesh::renumberNodesInConn(const int *newNodeNumbersO2N) * \param [in] fullyIn input that specifies if all node ids must be in [\a begin,\a end) array to consider cell to be in. * \param [in,out] cellIdsKeptArr array where all candidate cell ids are put at the end. */ -void MEDCoupling1DGTUMesh::fillCellIdsToKeepFromNodeIds(const int *begin, const int *end, bool fullyIn, DataArrayInt *&cellIdsKeptArr) const +void MEDCoupling1DGTUMesh::fillCellIdsToKeepFromNodeIds(const mcIdType *begin, const mcIdType *end, bool fullyIn, DataArrayIdType *&cellIdsKeptArr) const { - int nbOfCells=getNumberOfCells(); - MEDCouplingAutoRefCountObjectPtr cellIdsKept=DataArrayInt::New(); cellIdsKept->alloc(0,1); - int tmp=-1; - int sz=_conn->getMaxValue(tmp); sz=std::max(sz,0)+1; + mcIdType nbOfCells=getNumberOfCells(); + MCAuto cellIdsKept=DataArrayIdType::New(); cellIdsKept->alloc(0,1); + mcIdType tmp=-1; + mcIdType sz=_conn->getMaxValue(tmp); sz=std::max(sz,ToIdType(0))+1; std::vector fastFinder(sz,false); - for(const int *work=begin;work!=end;work++) + for(const mcIdType *work=begin;work!=end;work++) if(*work>=0 && *workbegin(),*conni=_conn_indx->begin(); - for(int i=0;ibegin(),*conni=_conn_indx->begin(); + for(mcIdType i=0;i=0) { - for(int j=0;j=0) { ref++; @@ -2407,13 +3276,13 @@ void MEDCoupling1DGTUMesh::fillCellIdsToKeepFromNodeIds(const int *begin, const cellIdsKeptArr=cellIdsKept.retn(); } -void MEDCoupling1DGTUMesh::allocateCells(int nbOfCells) throw(INTERP_KERNEL::Exception) +void MEDCoupling1DGTUMesh::allocateCells(mcIdType nbOfCells) { if(nbOfCells<0) throw INTERP_KERNEL::Exception("MEDCoupling1DGTUMesh::allocateCells : the input number of cells should be >= 0 !"); - _conn=DataArrayInt::New(); + _conn=DataArrayIdType::New(); _conn->reserve(nbOfCells*3); - _conn_indx=DataArrayInt::New(); + _conn_indx=DataArrayIdType::New(); _conn_indx->reserve(nbOfCells+1); _conn_indx->pushBackSilent(0); declareAsNew(); } @@ -2425,19 +3294,19 @@ void MEDCoupling1DGTUMesh::allocateCells(int nbOfCells) throw(INTERP_KERNEL::Exc * \param [in] nodalConnOfCellEnd - the end (excluded) of nodal connectivity of the cell to add. * \throw If the length of the input nodal connectivity array of the cell to add is not equal to number of nodes per cell relative to the unique geometric type * attached to \a this. - * \thow If the nodal connectivity array in \a this is null (call MEDCoupling1SGTUMesh::allocateCells before). + * \throw If the nodal connectivity array in \a this is null (call MEDCoupling1SGTUMesh::allocateCells before). */ -void MEDCoupling1DGTUMesh::insertNextCell(const int *nodalConnOfCellBg, const int *nodalConnOfCellEnd) throw(INTERP_KERNEL::Exception) +void MEDCoupling1DGTUMesh::insertNextCell(const mcIdType *nodalConnOfCellBg, const mcIdType *nodalConnOfCellEnd) { - int sz=(int)std::distance(nodalConnOfCellBg,nodalConnOfCellEnd); - DataArrayInt *c(_conn),*c2(_conn_indx); + std::size_t sz(std::distance(nodalConnOfCellBg,nodalConnOfCellEnd)); + DataArrayIdType *c(_conn),*c2(_conn_indx); if(c && c2) { - int pos=c2->back(); + mcIdType pos=c2->back(); if(pos==c->getNumberOfTuples()) { c->pushBackValsSilent(nodalConnOfCellBg,nodalConnOfCellEnd); - c2->pushBackSilent(pos+sz); + c2->pushBackSilent(pos+ToIdType(sz)); } else { @@ -2449,7 +3318,7 @@ void MEDCoupling1DGTUMesh::insertNextCell(const int *nodalConnOfCellBg, const in throw INTERP_KERNEL::Exception("MEDCoupling1DGTUMesh::insertNextCell : nodal connectivity array is null ! Call MEDCoupling1DGTUMesh::allocateCells before !"); } -void MEDCoupling1DGTUMesh::setNodalConnectivity(DataArrayInt *nodalConn, DataArrayInt *nodalConnIndex) throw(INTERP_KERNEL::Exception) +void MEDCoupling1DGTUMesh::setNodalConnectivity(DataArrayIdType *nodalConn, DataArrayIdType *nodalConnIndex) { if(nodalConn) nodalConn->incrRef(); @@ -2461,21 +3330,21 @@ void MEDCoupling1DGTUMesh::setNodalConnectivity(DataArrayInt *nodalConn, DataArr } /*! - * \return DataArrayInt * - the internal reference to the nodal connectivity. The caller is not reponsible to deallocate it. + * \return DataArrayIdType * - the internal reference to the nodal connectivity. The caller is not responsible to deallocate it. */ -DataArrayInt *MEDCoupling1DGTUMesh::getNodalConnectivity() const throw(INTERP_KERNEL::Exception) +DataArrayIdType *MEDCoupling1DGTUMesh::getNodalConnectivity() const { - const DataArrayInt *ret(_conn); - return const_cast(ret); + const DataArrayIdType *ret(_conn); + return const_cast(ret); } /*! - * \return DataArrayInt * - the internal reference to the nodal connectivity index. The caller is not reponsible to deallocate it. + * \return DataArrayIdType * - the internal reference to the nodal connectivity index. The caller is not responsible to deallocate it. */ -DataArrayInt *MEDCoupling1DGTUMesh::getNodalConnectivityIndex() const throw(INTERP_KERNEL::Exception) +DataArrayIdType *MEDCoupling1DGTUMesh::getNodalConnectivityIndex() const { - const DataArrayInt *ret(_conn_indx); - return const_cast(ret); + const DataArrayIdType *ret(_conn_indx); + return const_cast(ret); } /*! @@ -2491,12 +3360,12 @@ DataArrayInt *MEDCoupling1DGTUMesh::getNodalConnectivityIndex() const throw(INTE * * \sa MEDCoupling1DGTUMesh::retrievePackedNodalConnectivity, MEDCoupling1DGTUMesh::isPacked */ -MEDCoupling1DGTUMesh *MEDCoupling1DGTUMesh::copyWithNodalConnectivityPacked(bool& isShallowCpyOfNodalConnn) const throw(INTERP_KERNEL::Exception) +MEDCoupling1DGTUMesh *MEDCoupling1DGTUMesh::copyWithNodalConnectivityPacked(bool& isShallowCpyOfNodalConnn) const { - MEDCouplingAutoRefCountObjectPtr ret(new MEDCoupling1DGTUMesh(getName().c_str(),*_cm)); - DataArrayInt *nc=0,*nci=0; + MCAuto ret(new MEDCoupling1DGTUMesh(getName(),*_cm)); + DataArrayIdType *nc=0,*nci=0; isShallowCpyOfNodalConnn=retrievePackedNodalConnectivity(nc,nci); - MEDCouplingAutoRefCountObjectPtr ncs(nc),ncis(nci); + MCAuto ncs(nc),ncis(nci); ret->_conn=ncs; ret->_conn_indx=ncis; ret->setCoords(getCoords()); return ret.retn(); @@ -2504,7 +3373,7 @@ MEDCoupling1DGTUMesh *MEDCoupling1DGTUMesh::copyWithNodalConnectivityPacked(bool /*! * This method allows to compute, if needed, the packed nodal connectivity pair. - * Indeed, it is possible to store in \a this a nodal connectivity array bigger than ranges convered by nodal connectivity index array. + * Indeed, it is possible to store in \a this a nodal connectivity array bigger than ranges covered by nodal connectivity index array. * It is typically the case when nodalConnIndx starts with an id greater than 0, and finishes with id less than number of tuples in \c this->_conn. * * If \a this looks packed (the front of nodal connectivity index equal to 0 and back of connectivity index equal to number of tuple of nodal connectivity array) @@ -2521,20 +3390,20 @@ MEDCoupling1DGTUMesh *MEDCoupling1DGTUMesh::copyWithNodalConnectivityPacked(bool * \return bool - an indication of the content of the 2 output parameters. If true, \a this looks packed (general case), if true, \a this is not packed then * output parameters are newly created objects. * - * \throw if \a this does not pass MEDCoupling1DGTUMesh::checkCoherency test + * \throw if \a this does not pass MEDCoupling1DGTUMesh::checkConsistencyLight test */ -bool MEDCoupling1DGTUMesh::retrievePackedNodalConnectivity(DataArrayInt *&nodalConn, DataArrayInt *&nodalConnIndx) const throw(INTERP_KERNEL::Exception) +bool MEDCoupling1DGTUMesh::retrievePackedNodalConnectivity(DataArrayIdType *&nodalConn, DataArrayIdType *&nodalConnIndx) const { - if(isPacked())//performs the checkCoherency + if(isPacked())//performs the checkConsistencyLight { - const DataArrayInt *c0(_conn),*c1(_conn_indx); - nodalConn=const_cast(c0); nodalConnIndx=const_cast(c1); + const DataArrayIdType *c0(_conn),*c1(_conn_indx); + nodalConn=const_cast(c0); nodalConnIndx=const_cast(c1); nodalConn->incrRef(); nodalConnIndx->incrRef(); return true; } - int bg=_conn_indx->front(),end=_conn_indx->back(); - MEDCouplingAutoRefCountObjectPtr nc(_conn->selectByTupleId2(bg,end,1)); - MEDCouplingAutoRefCountObjectPtr nci(_conn_indx->deepCpy()); + mcIdType bg=_conn_indx->front(),end=_conn_indx->back(); + MCAuto nc(_conn->selectByTupleIdSafeSlice(bg,end,1)); + MCAuto nci(_conn_indx->deepCopy()); nci->applyLin(1,-bg); nodalConn=nc.retn(); nodalConnIndx=nci.retn(); return false; @@ -2546,22 +3415,22 @@ bool MEDCoupling1DGTUMesh::retrievePackedNodalConnectivity(DataArrayInt *&nodalC * If nodal connectivity index points to a subpart of nodal connectivity index false will be returned. * \return bool - true if \a this looks packed, false is not. * - * \throw if \a this does not pass MEDCoupling1DGTUMesh::checkCoherency test + * \throw if \a this does not pass MEDCoupling1DGTUMesh::checkConsistencyLight test */ -bool MEDCoupling1DGTUMesh::isPacked() const throw(INTERP_KERNEL::Exception) +bool MEDCoupling1DGTUMesh::isPacked() const { - checkCoherency(); + checkConsistencyLight(); return _conn_indx->front()==0 && _conn_indx->back()==_conn->getNumberOfTuples(); } -MEDCoupling1DGTUMesh *MEDCoupling1DGTUMesh::Merge1DGTUMeshes(const MEDCoupling1DGTUMesh *mesh1, const MEDCoupling1DGTUMesh *mesh2) throw(INTERP_KERNEL::Exception) +MEDCoupling1DGTUMesh *MEDCoupling1DGTUMesh::Merge1DGTUMeshes(const MEDCoupling1DGTUMesh *mesh1, const MEDCoupling1DGTUMesh *mesh2) { std::vector tmp(2); tmp[0]=const_cast(mesh1); tmp[1]=const_cast(mesh2); return Merge1DGTUMeshes(tmp); } -MEDCoupling1DGTUMesh *MEDCoupling1DGTUMesh::Merge1DGTUMeshes(std::vector& a) throw(INTERP_KERNEL::Exception) +MEDCoupling1DGTUMesh *MEDCoupling1DGTUMesh::Merge1DGTUMeshes(std::vector& a) { std::size_t sz=a.size(); if(sz==0) @@ -2576,17 +3445,17 @@ MEDCoupling1DGTUMesh *MEDCoupling1DGTUMesh::Merge1DGTUMeshes(std::vectorgetCellModel())!=cm) throw INTERP_KERNEL::Exception("MEDCoupling1DGTUMesh::Merge1DGTUMeshes : all items must have the same geo type !"); - std::vector< MEDCouplingAutoRefCountObjectPtr > bb(sz); + std::vector< MCAuto > bb(sz); std::vector< const MEDCoupling1DGTUMesh * > aa(sz); - int spaceDim=-3; - for(std::size_t i=0;igetCoords(); if(coo) spaceDim=coo->getNumberOfComponents(); } - if(spaceDim==-3) + if(spaceDim==spaceDimUndef) throw INTERP_KERNEL::Exception("MEDCoupling1DGTUMesh::Merge1DGTUMeshes : no spaceDim specified ! unable to perform merge !"); for(std::size_t i=0;i& a) throw(INTERP_KERNEL::Exception) +MEDCoupling1DGTUMesh *MEDCoupling1DGTUMesh::Merge1DGTUMeshesOnSameCoords(std::vector& a) { if(a.empty()) throw INTERP_KERNEL::Exception("MEDCoupling1DGTUMesh::Merge1DGTUMeshesOnSameCoords : input array must be NON EMPTY !"); std::vector::const_iterator it=a.begin(); if(!(*it)) throw INTERP_KERNEL::Exception("MEDCoupling1DGTUMesh::Merge1DGTUMeshesOnSameCoords : null instance in the first element of input vector !"); - std::vector< MEDCouplingAutoRefCountObjectPtr > objs(a.size()); - std::vector ncs(a.size()),ncis(a.size()); - int nbOfCells=(*it)->getNumberOfCells(); + std::vector< MCAuto > objs(a.size()); + std::vector ncs(a.size()),ncis(a.size()); + (*it)->getNumberOfCells();//to check that all is OK const DataArrayDouble *coords=(*it)->getCoords(); const INTERP_KERNEL::CellModel *cm=&((*it)->getCellModel()); bool tmp; @@ -2628,30 +3497,30 @@ MEDCoupling1DGTUMesh *MEDCoupling1DGTUMesh::Merge1DGTUMeshesOnSameCoords(std::ve if(coords!=(*it)->getCoords()) throw INTERP_KERNEL::Exception("MEDCoupling1DGTUMesh::Merge1DGTUMeshesOnSameCoords : not lying on same coords !"); } - MEDCouplingAutoRefCountObjectPtr ret(new MEDCoupling1DGTUMesh("merge",*cm)); + MCAuto ret(new MEDCoupling1DGTUMesh("merge",*cm)); ret->setCoords(coords); - ret->_conn=DataArrayInt::Aggregate(ncs); - ret->_conn_indx=DataArrayInt::AggregateIndexes(ncis); + ret->_conn=DataArrayIdType::Aggregate(ncs); + ret->_conn_indx=DataArrayIdType::AggregateIndexes(ncis); return ret.retn(); } /*! * Assume that all instances in \a a are non null. If null it leads to a crash. That's why this method is assigned to be low level (LL) */ -MEDCoupling1DGTUMesh *MEDCoupling1DGTUMesh::Merge1DGTUMeshesLL(std::vector& a) throw(INTERP_KERNEL::Exception) +MEDCoupling1DGTUMesh *MEDCoupling1DGTUMesh::Merge1DGTUMeshesLL(std::vector& a) { if(a.empty()) throw INTERP_KERNEL::Exception("MEDCoupling1DGTUMesh::Merge1DGTUMeshes : input array must be NON EMPTY !"); - std::vector< MEDCouplingAutoRefCountObjectPtr > objs(a.size()); - std::vector ncs(a.size()),ncis(a.size()); + std::vector< MCAuto > objs(a.size()); + std::vector ncs(a.size()),ncis(a.size()); std::vector::const_iterator it=a.begin(); - std::vector nbNodesPerElt(a.size()); - int nbOfCells=(*it)->getNumberOfCells(); + std::vector nbNodesPerElt(a.size()); + std::size_t nbOfCells=(*it)->getNumberOfCells(); bool tmp; objs[0]=(*it)->copyWithNodalConnectivityPacked(tmp); ncs[0]=objs[0]->getNodalConnectivity(); ncis[0]=objs[0]->getNodalConnectivityIndex(); nbNodesPerElt[0]=0; - int prevNbOfNodes=(*it)->getNumberOfNodes(); + mcIdType prevNbOfNodes=(*it)->getNumberOfNodes(); const INTERP_KERNEL::CellModel *cm=&((*it)->getCellModel()); it++; for(int i=1;it!=a.end();i++,it++) @@ -2666,22 +3535,22 @@ MEDCoupling1DGTUMesh *MEDCoupling1DGTUMesh::Merge1DGTUMeshesLL(std::vector aps(a.size()); std::copy(a.begin(),a.end(),aps.begin()); - MEDCouplingAutoRefCountObjectPtr pts=MergeNodesArray(aps); - MEDCouplingAutoRefCountObjectPtr ret(new MEDCoupling1DGTUMesh("merge",*cm)); + MCAuto pts=MergeNodesArray(aps); + MCAuto ret(new MEDCoupling1DGTUMesh("merge",*cm)); ret->setCoords(pts); ret->_conn=AggregateNodalConnAndShiftNodeIds(ncs,nbNodesPerElt); - ret->_conn_indx=DataArrayInt::AggregateIndexes(ncis); + ret->_conn_indx=DataArrayIdType::AggregateIndexes(ncis); return ret.retn(); } -MEDCoupling1DGTUMesh *MEDCoupling1DGTUMesh::buildSetInstanceFromThis(int spaceDim) const throw(INTERP_KERNEL::Exception) +MEDCoupling1DGTUMesh *MEDCoupling1DGTUMesh::buildSetInstanceFromThis(std::size_t spaceDim) const { - MEDCouplingAutoRefCountObjectPtr ret(new MEDCoupling1DGTUMesh(getName().c_str(),*_cm)); - MEDCouplingAutoRefCountObjectPtr tmp1,tmp2; - const DataArrayInt *nodalConn(_conn),*nodalConnI(_conn_indx); + MCAuto ret(new MEDCoupling1DGTUMesh(getName(),*_cm)); + MCAuto tmp1,tmp2; + const DataArrayIdType *nodalConn(_conn),*nodalConnI(_conn_indx); if(!nodalConn) { - tmp1=DataArrayInt::New(); tmp1->alloc(0,1); + tmp1=DataArrayIdType::New(); tmp1->alloc(0,1); } else tmp1=_conn; @@ -2689,7 +3558,7 @@ MEDCoupling1DGTUMesh *MEDCoupling1DGTUMesh::buildSetInstanceFromThis(int spaceDi // if(!nodalConnI) { - tmp2=DataArrayInt::New(); tmp2->alloc(1,1); tmp2->setIJ(0,0,0); + tmp2=DataArrayIdType::New(); tmp2->alloc(1,1); tmp2->setIJ(0,0,0); } else tmp2=_conn_indx; @@ -2697,7 +3566,7 @@ MEDCoupling1DGTUMesh *MEDCoupling1DGTUMesh::buildSetInstanceFromThis(int spaceDi // if(!_coords) { - MEDCouplingAutoRefCountObjectPtr coords=DataArrayDouble::New(); coords->alloc(0,spaceDim); + MCAuto coords=DataArrayDouble::New(); coords->alloc(0,spaceDim); ret->setCoords(coords); } else @@ -2706,27 +3575,126 @@ MEDCoupling1DGTUMesh *MEDCoupling1DGTUMesh::buildSetInstanceFromThis(int spaceDi } /*! - * This method performs an aggregation of \a nodalConns (as DataArrayInt::Aggregate does) but in addition of that a shift is applied on the + * This method aggregate the bbox of each cell and put it into bbox parameter. + * + * \param [in] arcDetEps - a parameter specifying in case of 2D quadratic polygon cell the detection limit between linear and arc circle. (By default 1e-12) + * For all other cases this input parameter is ignored. + * \return DataArrayDouble * - newly created object (to be managed by the caller) \a this number of cells tuples and 2*spacedim components. + * + * \throw If \a this is not fully set (coordinates and connectivity). + * \throw If a cell in \a this has no valid nodeId. + */ +DataArrayDouble *MEDCoupling1DGTUMesh::getBoundingBoxForBBTree(double arcDetEps) const +{ + checkFullyDefined(); + mcIdType spaceDim(getSpaceDimension()),nbOfCells(getNumberOfCells()),nbOfNodes(getNumberOfNodes()); + MCAuto ret(DataArrayDouble::New()); ret->alloc(nbOfCells,2*spaceDim); + double *bbox(ret->getPointer()); + for(mcIdType i=0;i::max(); + bbox[2*i+1]=-std::numeric_limits::max(); + } + const double *coordsPtr(_coords->getConstPointer()); + const mcIdType *conn(_conn->getConstPointer()),*connI(_conn_indx->getConstPointer()); + for(mcIdType i=0;i=0 && nodeId MEDCoupling1DGTUMesh::BuildAPolygonFromParts(const std::vector< std::vector >& parts) +{ + std::vector ret; + if(parts.empty()) + return ret; + ret.insert(ret.end(),parts[0].begin(),parts[0].end()); + mcIdType ref(ret.back()); + std::size_t sz(parts.size()),nbh(1); + std::vector b(sz,true); b[0]=false; + while(nbh oi(INTERP_KERNEL::OrientationInverter::BuildInstanceFrom(getCellModelEnum())); + mcIdType nbCells=getNumberOfCells(); + const mcIdType *connI(_conn_indx->begin()); + mcIdType *conn(_conn->getPointer()); + for(mcIdType i=0;ioperate(conn+connI[i],conn+connI[i+1]); + updateTime(); +} + +/*! + * This method performs an aggregation of \a nodalConns (as DataArrayIdType::Aggregate does) but in addition of that a shift is applied on the * values contained in \a nodalConns using corresponding offset specified in input \a offsetInNodeIdsPerElt. * But it also manage the values -1, that have a semantic in MEDCoupling1DGTUMesh class (separator for polyhedron). * * \param [in] nodalConns - a list of nodal connectivity arrays same size than \a offsetInNodeIdsPerElt. * \param [in] offsetInNodeIdsPerElt - a list of offsets to apply. - * \return DataArrayInt * - A new object (to be managed by the caller) that is the result of the aggregation. + * \return DataArrayIdType * - A new object (to be managed by the caller) that is the result of the aggregation. * \throw If \a nodalConns or \a offsetInNodeIdsPerElt are empty. * \throw If \a nodalConns and \a offsetInNodeIdsPerElt have not the same size. * \throw If presence of null pointer in \a nodalConns. * \throw If presence of not allocated or array with not exactly one component in \a nodalConns. */ -DataArrayInt *MEDCoupling1DGTUMesh::AggregateNodalConnAndShiftNodeIds(const std::vector& nodalConns, const std::vector& offsetInNodeIdsPerElt) throw(INTERP_KERNEL::Exception) +DataArrayIdType *MEDCoupling1DGTUMesh::AggregateNodalConnAndShiftNodeIds(const std::vector& nodalConns, const std::vector& offsetInNodeIdsPerElt) { std::size_t sz1(nodalConns.size()),sz2(offsetInNodeIdsPerElt.size()); if(sz1!=sz2) throw INTERP_KERNEL::Exception("MEDCoupling1DGTUMesh::AggregateNodalConnAndShiftNodeIds : input vectors do not have the same size !"); if(sz1==0) throw INTERP_KERNEL::Exception("MEDCoupling1DGTUMesh::AggregateNodalConnAndShiftNodeIds : empty vectors in input !"); - int nbOfTuples=0; - for(std::vector::const_iterator it=nodalConns.begin();it!=nodalConns.end();it++) + mcIdType nbOfTuples=0; + for(std::vector::const_iterator it=nodalConns.begin();it!=nodalConns.end();it++) { if(!(*it)) throw INTERP_KERNEL::Exception("MEDCoupling1DGTUMesh::AggregateNodalConnAndShiftNodeIds : presence of null pointer in input vector !"); @@ -2736,15 +3704,15 @@ DataArrayInt *MEDCoupling1DGTUMesh::AggregateNodalConnAndShiftNodeIds(const std: throw INTERP_KERNEL::Exception("MEDCoupling1DGTUMesh::AggregateNodalConnAndShiftNodeIds : presence of array with not exactly one component !"); nbOfTuples+=(*it)->getNumberOfTuples(); } - MEDCouplingAutoRefCountObjectPtr ret=DataArrayInt::New(); ret->alloc(nbOfTuples,1); - int *pt=ret->getPointer(); - int i=0; - for(std::vector::const_iterator it=nodalConns.begin();it!=nodalConns.end();it++,i++) + MCAuto ret=DataArrayIdType::New(); ret->alloc(nbOfTuples,1); + mcIdType *pt=ret->getPointer(); + mcIdType i=0; + for(std::vector::const_iterator it=nodalConns.begin();it!=nodalConns.end();it++,i++) { - int curNbt=(*it)->getNumberOfTuples(); - const int *inPt=(*it)->begin(); - int offset=offsetInNodeIdsPerElt[i]; - for(int j=0;jgetNumberOfTuples(); + const mcIdType *inPt=(*it)->begin(); + mcIdType offset=offsetInNodeIdsPerElt[i]; + for(mcIdType j=0;j gts(m->getAllGeoTypes()); if(gts.size()!=1) throw INTERP_KERNEL::Exception("MEDCoupling1DGTUMesh::New : input mesh must have exactly one geometric type !"); - int geoType((int)*gts.begin()); - MEDCouplingAutoRefCountObjectPtr ret(MEDCoupling1DGTUMesh::New(m->getName().c_str(),*gts.begin())); - ret->setCoords(m->getCoords()); ret->setDescription(m->getDescription().c_str()); - int nbCells(m->getNumberOfCells()); - MEDCouplingAutoRefCountObjectPtr conn(DataArrayInt::New()),connI(DataArrayInt::New()); - conn->alloc(m->getMeshLength()-nbCells,1); connI->alloc(nbCells+1,1); - int *c(conn->getPointer()),*ci(connI->getPointer()); *ci=0; - const int *cin(m->getNodalConnectivity()->begin()),*ciin(m->getNodalConnectivityIndex()->begin()); - for(int i=0;i ret(MEDCoupling1DGTUMesh::New(m->getName(),*gts.begin())); + ret->setCoords(m->getCoords()); ret->setDescription(m->getDescription()); + mcIdType nbCells=m->getNumberOfCells(); + MCAuto conn(DataArrayIdType::New()),connI(DataArrayIdType::New()); + conn->alloc(m->getNodalConnectivityArrayLen()-nbCells,1); connI->alloc(nbCells+1,1); + mcIdType *c(conn->getPointer()),*ci(connI->getPointer()); *ci=0; + const mcIdType *cin(m->getNodalConnectivity()->begin()),*ciin(m->getNodalConnectivityIndex()->begin()); + for(mcIdType i=0;i