X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FMEDCoupling%2FMEDCoupling1GTUMesh.cxx;h=a5ae41bd0bc46717ff7f7281a046939d4d6fdef3;hb=refs%2Fheads%2Fbos%2F33389;hp=3e15f5255aa5459a5c40c0c87bb221d8574e510e;hpb=a23c622fadddf57290253debb129d9008226cdb9;p=tools%2Fmedcoupling.git diff --git a/src/MEDCoupling/MEDCoupling1GTUMesh.cxx b/src/MEDCoupling/MEDCoupling1GTUMesh.cxx index 3e15f5255..a5ae41bd0 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-2022 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,21 +16,28 @@ // // 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" +#include "VolSurfUser.txx" -using namespace ParaMEDMEM; +using namespace MEDCoupling; -MEDCoupling1GTUMesh::MEDCoupling1GTUMesh() +const int MEDCoupling1SGTUMesh::HEXA8_FACE_PAIRS[6]={0,1,2,4,3,5}; + +MEDCoupling1GTUMesh::MEDCoupling1GTUMesh():_cm(0) { } -MEDCoupling1GTUMesh::MEDCoupling1GTUMesh(const char *name, const INTERP_KERNEL::CellModel& cm):_cm(&cm) +MEDCoupling1GTUMesh::MEDCoupling1GTUMesh(const std::string& name, const INTERP_KERNEL::CellModel& cm):_cm(&cm) { setName(name); } @@ -39,7 +46,7 @@ MEDCoupling1GTUMesh::MEDCoupling1GTUMesh(const MEDCoupling1GTUMesh& other, bool { } -MEDCoupling1GTUMesh *MEDCoupling1GTUMesh::New(const char *name, INTERP_KERNEL::NormalizedCellType type) +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 !"); @@ -88,9 +95,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 +DataArrayIdType *MEDCoupling1GTUMesh::giveCellsWithType(INTERP_KERNEL::NormalizedCellType type) const { - MEDCouplingAutoRefCountObjectPtr ret=DataArrayInt::New(); + MCAuto ret=DataArrayIdType::New(); if(type==getCellModelEnum()) ret->alloc(getNumberOfCells(),1); else @@ -102,7 +109,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; } @@ -113,9 +120,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 +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; } @@ -172,29 +179,28 @@ std::vector MEDCoupling1GTUMesh::getDistributionOfTypes() const * - 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 +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); } /*! @@ -203,12 +209,12 @@ void MEDCoupling1GTUMesh::splitProfilePerType(const DataArrayInt *profile, std:: * * \sa MEDCouplingUMesh::checkTypeConsistencyAndContig */ -DataArrayInt *MEDCoupling1GTUMesh::checkTypeConsistencyAndContig(const std::vector& code, const std::vector& idsPerType) const +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()); @@ -226,20 +232,20 @@ 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, DataArrayByte *byteData) const { - MEDCouplingAutoRefCountObjectPtr m=buildUnstructured(); + MCAuto m=buildUnstructured(); m->writeVTKLL(ofs,cellData,pointData,byteData); } @@ -248,6 +254,11 @@ std::string MEDCoupling1GTUMesh::getVTKDataSetType() const return std::string("UnstructuredGrid"); } +std::string MEDCoupling1GTUMesh::getVTKFileExtension() const +{ + return std::string("vtu"); +} + std::size_t MEDCoupling1GTUMesh::getHeapMemorySizeWithoutChildren() const { return MEDCouplingPointSet::getHeapMemorySizeWithoutChildren(); @@ -287,30 +298,30 @@ bool MEDCoupling1GTUMesh::isEqualWithoutConsideringStr(const MEDCouplingMesh *ot return true; } -void MEDCoupling1GTUMesh::checkCoherency() const +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(); } @@ -318,59 +329,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 +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 +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) @@ -402,9 +422,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)) @@ -416,19 +436,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) { } @@ -478,7 +498,7 @@ MEDCoupling1SGTUMesh *MEDCoupling1SGTUMesh::New() return new MEDCoupling1SGTUMesh; } -MEDCoupling1SGTUMesh *MEDCoupling1SGTUMesh::New(const char *name, INTERP_KERNEL::NormalizedCellType type) +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 !"); @@ -498,15 +518,15 @@ MEDCoupling1SGTUMesh *MEDCoupling1SGTUMesh::New(const MEDCouplingUMesh *m) 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(); } @@ -534,17 +557,17 @@ 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 +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(); } @@ -562,7 +585,7 @@ void MEDCoupling1SGTUMesh::shallowCopyConnectivityFrom(const MEDCouplingPointSet void MEDCoupling1SGTUMesh::updateTime() const { MEDCoupling1GTUMesh::updateTime(); - const DataArrayInt *c(_conn); + const DataArrayIdType *c(_conn); if(c) updateTimeWith(*c); } @@ -572,16 +595,14 @@ std::size_t MEDCoupling1SGTUMesh::getHeapMemorySizeWithoutChildren() const return MEDCoupling1GTUMesh::getHeapMemorySizeWithoutChildren(); } -std::vector MEDCoupling1SGTUMesh::getDirectChildren() const +std::vector MEDCoupling1SGTUMesh::getDirectChildrenWithNull() const { - std::vector ret(MEDCoupling1GTUMesh::getDirectChildren()); - const DataArrayInt *c(_conn); - if(c) - ret.push_back(c); + std::vector ret(MEDCoupling1GTUMesh::getDirectChildrenWithNull()); + ret.push_back((const DataArrayIdType *)_conn); return ret; } -MEDCouplingMesh *MEDCoupling1SGTUMesh::deepCpy() const +MEDCoupling1SGTUMesh *MEDCoupling1SGTUMesh::deepCopy() const { return clone(true); } @@ -599,7 +620,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) @@ -609,7 +630,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; @@ -624,7 +645,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) @@ -634,9 +655,9 @@ bool MEDCoupling1SGTUMesh::isEqualWithoutConsideringStr(const MEDCouplingMesh *o return true; } -void MEDCoupling1SGTUMesh::checkCoherencyOfConnectivity() const +void MEDCoupling1SGTUMesh::checkConsistencyOfConnectivity() const { - const DataArrayInt *c1(_conn); + const DataArrayIdType *c1(_conn); if(c1) { if(c1->getNumberOfComponents()!=1) @@ -649,27 +670,27 @@ void MEDCoupling1SGTUMesh::checkCoherencyOfConnectivity() const throw INTERP_KERNEL::Exception("Nodal connectivity array not defined !"); } -void MEDCoupling1SGTUMesh::checkCoherency() const +void MEDCoupling1SGTUMesh::checkConsistencyLight() const { - MEDCouplingPointSet::checkCoherency(); - checkCoherencyOfConnectivity(); + MEDCouplingPointSet::checkConsistencyLight(); + checkConsistencyOfConnectivity(); } -void MEDCoupling1SGTUMesh::checkCoherency1(double eps) const +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) @@ -680,15 +701,10 @@ void MEDCoupling1SGTUMesh::checkCoherency1(double eps) const } } -void MEDCoupling1SGTUMesh::checkCoherency2(double eps) const -{ - 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 !"; @@ -697,57 +713,57 @@ int MEDCoupling1SGTUMesh::getNumberOfCells() const return nbOfTuples/nbOfNodesPerCell; } -int MEDCoupling1SGTUMesh::getNumberOfNodesInCell(int cellId) const +mcIdType MEDCoupling1SGTUMesh::getNumberOfNodesInCell(mcIdType cellId) const { return getNumberOfNodesPerCell(); } -int MEDCoupling1SGTUMesh::getNumberOfNodesPerCell() const +mcIdType MEDCoupling1SGTUMesh::getNumberOfNodesPerCell() const { checkNonDynamicGeoType(); - return (int)_cm->getNumberOfNodes(); + return _cm->getNumberOfNodes(); } -DataArrayInt *MEDCoupling1SGTUMesh::computeNbOfNodesPerCell() const +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 +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 +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 { @@ -766,6 +782,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; @@ -789,7 +810,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()) { @@ -818,21 +839,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"; @@ -847,20 +868,20 @@ std::string MEDCoupling1SGTUMesh::advancedRepr() const 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 @@ -868,31 +889,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) +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++; @@ -947,39 +968,42 @@ MEDCouplingMesh *MEDCoupling1SGTUMesh::mergeMyselfWith(const MEDCouplingMesh *ot 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) +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 @@ -987,37 +1011,61 @@ DataArrayInt *MEDCoupling1SGTUMesh::simplexize(int policy) 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 +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. @@ -1038,10 +1121,10 @@ 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()); @@ -1070,17 +1153,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::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++) @@ -1119,9 +1201,9 @@ 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(); } @@ -1133,9 +1215,9 @@ MEDCoupling1SGTUMesh *MEDCoupling1SGTUMesh::Merge1SGTUMeshesLL(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++) { @@ -1145,18 +1227,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(); } // @@ -1164,17 +1246,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 { - 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 +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 @@ -1256,16 +1334,16 @@ MEDCoupling1SGTUMesh *MEDCoupling1SGTUMesh::buildSetInstanceFromThis(int spaceDi return ret.retn(); } -DataArrayInt *MEDCoupling1SGTUMesh::simplexizePol0() +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 ; } @@ -1350,7 +1434,7 @@ void MEDCoupling1SGTUMesh::reprQuickOverview(std::ostream& stream) const { 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()) { @@ -1361,19 +1445,19 @@ void MEDCoupling1SGTUMesh::reprQuickOverview(std::ostream& stream) const 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 +void MEDCoupling1SGTUMesh::getTinySerializationInformation(std::vector& tinyInfoD, std::vector& tinyInfo, std::vector& littleStrings) const { int it,order; double time=getTime(it,order); @@ -1386,21 +1470,21 @@ void MEDCoupling1SGTUMesh::getTinySerializationInformation(std::vector& std::vector littleStrings2,littleStrings3; if((const DataArrayDouble *)_coords) _coords->getTinySerializationStrInformation(littleStrings2); - if((const DataArrayInt *)_conn) + if((const DataArrayIdType *)_conn) _conn->getTinySerializationStrInformation(littleStrings3); - int sz0((int)littleStrings2.size()),sz1((int)littleStrings3.size()); + 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; + std::vector tinyInfo2,tinyInfo3; if((const DataArrayDouble *)_coords) _coords->getTinySerializationIntInformation(tinyInfo2); - if((const DataArrayInt *)_conn) + if((const DataArrayIdType *)_conn) _conn->getTinySerializationIntInformation(tinyInfo3); - int sz2((int)tinyInfo2.size()),sz3((int)tinyInfo3.size()); + 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()); @@ -1408,23 +1492,23 @@ void MEDCoupling1SGTUMesh::getTinySerializationInformation(std::vector& tinyInfoD.push_back(time); } -void MEDCoupling1SGTUMesh::resizeForUnserialization(const std::vector& tinyInfo, DataArrayInt *a1, DataArrayDouble *a2, std::vector& littleStrings) const +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]); + 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(DataArrayInt *&a1, DataArrayDouble *&a2) const +void MEDCoupling1SGTUMesh::serialize(DataArrayIdType *&a1, DataArrayDouble *&a2) const { - int sz(0); - if((const DataArrayInt *)_conn) + mcIdType sz(0); + if((const DataArrayIdType *)_conn) if(_conn->isAllocated()) sz=_conn->getNbOfElems(); - a1=DataArrayInt::New(); + a1=DataArrayIdType::New(); a1->alloc(sz,1); - if(sz!=0 && (const DataArrayInt *)_conn) + if(sz!=0 && (const DataArrayIdType *)_conn) std::copy(_conn->begin(),_conn->end(),a1->getPointer()); sz=0; if((const DataArrayDouble *)_coords) @@ -1436,23 +1520,23 @@ void MEDCoupling1SGTUMesh::serialize(DataArrayInt *&a1, DataArrayDouble *&a2) co std::copy(_coords->begin(),_coords->end(),a2->getPointer()); } -void MEDCoupling1SGTUMesh::unserialization(const std::vector& tinyInfoD, const std::vector& tinyInfo, const DataArrayInt *a1, DataArrayDouble *a2, +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].c_str()); - setDescription(littleStrings[1].c_str()); - setTimeUnit(littleStrings[2].c_str()); - setTime(tinyInfoD[0],tinyInfo[1],tinyInfo[2]); - int sz0(tinyInfo[3]),sz1(tinyInfo[4]),sz2(tinyInfo[5]),sz3(tinyInfo[6]); + 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); + std::vector tinyInfo2(tinyInfo.begin()+7,tinyInfo.begin()+7+sz2); _coords->resizeForUnserialization(tinyInfo2); std::copy(a2->begin(),a2->end(),_coords->getPointer()); - _conn=DataArrayInt::New(); - std::vector tinyInfo3(tinyInfo.begin()+7+sz2,tinyInfo.begin()+7+sz2+sz3); + _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); @@ -1477,7 +1561,7 @@ void MEDCoupling1SGTUMesh::checkFastEquivalWith(const MEDCouplingMesh *other, do 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) @@ -1503,18 +1587,18 @@ MEDCouplingPointSet *MEDCoupling1SGTUMesh::mergeMyselfWithOnSameCoords(const MED return Merge1SGTUMeshesOnSameCoords(ms); } -void MEDCoupling1SGTUMesh::getReverseNodalConnectivity(DataArrayInt *revNodal, DataArrayInt *revNodalIndx) const +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; } } } @@ -1547,7 +1631,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) +void MEDCoupling1SGTUMesh::setNodalConnectivity(DataArrayIdType *nodalConn) { if(nodalConn) nodalConn->incrRef(); @@ -1556,26 +1640,26 @@ void MEDCoupling1SGTUMesh::setNodalConnectivity(DataArrayInt *nodalConn) } /*! - * \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 +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) +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(); } @@ -1587,15 +1671,15 @@ void MEDCoupling1SGTUMesh::allocateCells(int nbOfCells) * \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) +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 @@ -1623,14 +1707,269 @@ MEDCoupling1GTUMesh *MEDCoupling1SGTUMesh::computeDualMesh() const 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 for each cell in \a this the triangle height for each edge in a newly allocated/created array instance. + * + * \return DataArrayDouble * - a newly allocated instance with this->getNumberOfCells() tuples and 3 components storing for each cell in \a this the corresponding height. + * \throw If \a this is not a mesh containing only NORM_TRI3 cells. + * \throw If \a this is not properly allocated. + * \throw If spaceDimension is not in 2 or 3. + */ +MCAuto MEDCoupling1SGTUMesh::computeTriangleHeight() const +{ + checkConsistencyLight(); + const INTERP_KERNEL::CellModel& cm(getCellModel()); + if(cm.getEnum()!=INTERP_KERNEL::NORM_TRI3) + THROW_IK_EXCEPTION("MEDCoupling1SGTUMesh::computeTriangleHeight : this method can be applied only on TRI3 mesh !"); + MCAuto ret(DataArrayDouble::New()); + mcIdType nbTri3( getNumberOfCells() ); + const double *coordPtr( this->getCoords()->begin() ); + const mcIdType *inConnPtr(getNodalConnectivity()->begin()); + ret->alloc(nbTri3,3); + double *retPtr( ret->getPointer() ); + switch( this->getSpaceDimension()) + { + case 2: + { + constexpr unsigned SPACEDIM = 2; + for(mcIdType iCell = 0 ; iCell < nbTri3 ; ++iCell) + { + INTERP_KERNEL::ComputeTriangleHeight(coordPtr + SPACEDIM*inConnPtr[3*iCell+0], coordPtr + SPACEDIM*inConnPtr[3*iCell+1], coordPtr + SPACEDIM*inConnPtr[3*iCell+2],retPtr+3*iCell); + } + break; + } + case 3: + { + constexpr unsigned SPACEDIM = 3; + for(mcIdType iCell = 0 ; iCell < nbTri3 ; ++iCell) + { + INTERP_KERNEL::ComputeTriangleHeight(coordPtr + SPACEDIM*inConnPtr[3*iCell+0], coordPtr + SPACEDIM*inConnPtr[3*iCell+1], coordPtr + SPACEDIM*inConnPtr[3*iCell+2],retPtr+3*iCell); + } + break; + } + default: + THROW_IK_EXCEPTION("MEDCoupling1SGTUMesh::computeTriangleHeight : only spacedim in [2,3] supported !"); + } + return ret; +} + +/*! + * 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 @@ -1651,27 +1990,29 @@ MEDCoupling1DGTUMesh *MEDCoupling1SGTUMesh::computeDualMesh3D() const if(getCellModelEnum()!=INTERP_KERNEL::NORM_TETRA4) throw INTERP_KERNEL::Exception("MEDCoupling1SGTUMesh::computeDualMesh3D : only TETRA4 supported !"); checkFullyDefined(); - MEDCouplingAutoRefCountObjectPtr thisu(buildUnstructured()); - MEDCouplingAutoRefCountObjectPtr revNodArr(DataArrayInt::New()),revNodIArr(DataArrayInt::New()); + MCAuto thisu(buildUnstructured()); + MCAuto revNodArr(DataArrayIdType::New()),revNodIArr(DataArrayIdType::New()); thisu->getReverseNodalConnectivity(revNodArr,revNodIArr); - const int *revNod(revNodArr->begin()),*revNodI(revNodIArr->begin()),*nodal(_conn->begin()); - MEDCouplingAutoRefCountObjectPtr d1Arr(DataArrayInt::New()),di1Arr(DataArrayInt::New()),rd1Arr(DataArrayInt::New()),rdi1Arr(DataArrayInt::New()); - MEDCouplingAutoRefCountObjectPtr edges(thisu->explode3DMeshTo1D(d1Arr,di1Arr,rd1Arr,rdi1Arr)); - const int *d1(d1Arr->begin()); - MEDCouplingAutoRefCountObjectPtr d2Arr(DataArrayInt::New()),di2Arr(DataArrayInt::New()),rd2Arr(DataArrayInt::New()),rdi2Arr(DataArrayInt::New()); - MEDCouplingAutoRefCountObjectPtr faces(thisu->buildDescendingConnectivity(d2Arr,di2Arr,rd2Arr,rdi2Arr)); thisu=0; - const int *d2(d2Arr->begin()),*rd2(rd2Arr->begin()),*rdi2(rdi2Arr->begin()); - MEDCouplingAutoRefCountObjectPtr edgesBaryArr(edges->getBarycenterAndOwner()),facesBaryArr(faces->getBarycenterAndOwner()),baryArr(getBarycenterAndOwner()); - const int nbOfNodes(getNumberOfNodes()),offset0(nbOfNodes+faces->getNumberOfCells()),offset1(offset0+edges->getNumberOfCells()); + 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; - MEDCouplingAutoRefCountObjectPtr zeArr(DataArrayDouble::Aggregate(v)); baryArr=0; edgesBaryArr=0; facesBaryArr=0; + MCAuto zeArr(DataArrayDouble::Aggregate(v)); baryArr=0; edgesBaryArr=0; facesBaryArr=0; std::string name("DualOf_"); name+=getName(); - MEDCouplingAutoRefCountObjectPtr ret(MEDCoupling1DGTUMesh::New(name.c_str(),INTERP_KERNEL::NORM_POLYHED)); ret->setCoords(zeArr); - MEDCouplingAutoRefCountObjectPtr cArr(DataArrayInt::New()),ciArr(DataArrayInt::New()); ciArr->alloc(nbOfNodes+1,1); ciArr->setIJ(0,0,0); cArr->alloc(0,1); - for(int i=0;i 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); - int tmp[14]; + 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; @@ -1699,10 +2040,10 @@ MEDCoupling1DGTUMesh *MEDCoupling1SGTUMesh::computeDualMesh3D() const { if(FACEID_NOT_SH_NODE[nodePosInCurCell]!=k) { - const int *faceId(d2+4*curCellId+k); + const mcIdType *faceId(d2+4*curCellId+k); if(rdi2[*faceId+1]-rdi2[*faceId]==1) { - int tmp2[5]; tmp2[0]=-1; tmp2[1]=i; + 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; @@ -1726,36 +2067,36 @@ MEDCoupling1DGTUMesh *MEDCoupling1SGTUMesh::computeDualMesh2D() const if(getCellModelEnum()!=INTERP_KERNEL::NORM_TRI3) throw INTERP_KERNEL::Exception("MEDCoupling1SGTUMesh::computeDualMesh2D : only TRI3 supported !"); checkFullyDefined(); - MEDCouplingAutoRefCountObjectPtr thisu(buildUnstructured()); - MEDCouplingAutoRefCountObjectPtr revNodArr(DataArrayInt::New()),revNodIArr(DataArrayInt::New()); + MCAuto thisu(buildUnstructured()); + MCAuto revNodArr(DataArrayIdType::New()),revNodIArr(DataArrayIdType::New()); thisu->getReverseNodalConnectivity(revNodArr,revNodIArr); - const int *revNod(revNodArr->begin()),*revNodI(revNodIArr->begin()),*nodal(_conn->begin()); - MEDCouplingAutoRefCountObjectPtr d2Arr(DataArrayInt::New()),di2Arr(DataArrayInt::New()),rd2Arr(DataArrayInt::New()),rdi2Arr(DataArrayInt::New()); - MEDCouplingAutoRefCountObjectPtr edges(thisu->buildDescendingConnectivity(d2Arr,di2Arr,rd2Arr,rdi2Arr)); thisu=0; - const int *d2(d2Arr->begin()),*rd2(rd2Arr->begin()),*rdi2(rdi2Arr->begin()); - MEDCouplingAutoRefCountObjectPtr edgesBaryArr(edges->getBarycenterAndOwner()),baryArr(getBarycenterAndOwner()); - const int nbOfNodes(getNumberOfNodes()),offset0(nbOfNodes+edges->getNumberOfCells()); + 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; - MEDCouplingAutoRefCountObjectPtr zeArr(DataArrayDouble::Aggregate(v)); baryArr=0; edgesBaryArr=0; + MCAuto zeArr(DataArrayDouble::Aggregate(v)); baryArr=0; edgesBaryArr=0; std::string name("DualOf_"); name+=getName(); - MEDCouplingAutoRefCountObjectPtr ret(MEDCoupling1DGTUMesh::New(name.c_str(),INTERP_KERNEL::NORM_POLYGON)); ret->setCoords(zeArr); - MEDCouplingAutoRefCountObjectPtr cArr(DataArrayInt::New()),ciArr(DataArrayInt::New()); ciArr->alloc(nbOfNodes+1,1); ciArr->setIJ(0,0,0); cArr->alloc(0,1); - for(int i=0;i 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; + std::vector< std::vector > polyg; for(int j=0;j locV(3); + std::vector 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); @@ -1763,10 +2104,10 @@ MEDCoupling1DGTUMesh *MEDCoupling1SGTUMesh::computeDualMesh2D() const { if(FACEID_NOT_SH_NODE[nodePosInCurCell]!=k) { - const int *edgeId(d2+3*curCellId+k); + const mcIdType *edgeId(d2+3*curCellId+k); if(rdi2[*edgeId+1]-rdi2[*edgeId]==1) { - std::vector locV2(2); + 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; } @@ -1778,7 +2119,7 @@ MEDCoupling1DGTUMesh *MEDCoupling1SGTUMesh::computeDualMesh2D() const } } } - std::vector zePolyg(MEDCoupling1DGTUMesh::BuildAPolygonFromParts(polyg)); + std::vector zePolyg(MEDCoupling1DGTUMesh::BuildAPolygonFromParts(polyg)); cArr->insertAtTheEnd(zePolyg.begin(),zePolyg.end()); ciArr->setIJ(i+1,0,cArr->getNumberOfTuples()); } @@ -1789,29 +2130,31 @@ MEDCoupling1DGTUMesh *MEDCoupling1SGTUMesh::computeDualMesh2D() const /*! * 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() const +DataArrayDouble *MEDCoupling1SGTUMesh::getBoundingBoxForBBTree(double arcDetEps) const { - int spaceDim(getSpaceDimension()),nbOfCells(getNumberOfCells()),nbOfNodes(getNumberOfNodes()),nbOfNodesPerCell(getNumberOfNodesPerCell()); - MEDCouplingAutoRefCountObjectPtr ret(DataArrayDouble::New()); ret->alloc(nbOfCells,2*spaceDim); + mcIdType spaceDim(getSpaceDimension()),nbOfCells(getNumberOfCells()),nbOfNodes(getNumberOfNodes()),nbOfNodesPerCell(getNumberOfNodesPerCell()); + MCAuto ret(DataArrayDouble::New()); ret->alloc(nbOfCells,2*spaceDim); double *bbox(ret->getPointer()); - for(int i=0;i::max(); bbox[2*i+1]=-std::numeric_limits::max(); } const double *coordsPtr(_coords->getConstPointer()); - const int *conn(_conn->getConstPointer()); - for(int i=0;igetConstPointer()); + 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() @@ -1838,7 +2217,7 @@ MEDCoupling1DGTUMesh *MEDCoupling1DGTUMesh::New() return new MEDCoupling1DGTUMesh; } -MEDCoupling1DGTUMesh *MEDCoupling1DGTUMesh::New(const char *name, INTERP_KERNEL::NormalizedCellType type) +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 !"); @@ -1855,20 +2234,20 @@ MEDCoupling1DGTUMesh::MEDCoupling1DGTUMesh() { } -MEDCoupling1DGTUMesh::MEDCoupling1DGTUMesh(const char *name, const INTERP_KERNEL::CellModel& cm):MEDCoupling1GTUMesh(name,cm) +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(other._conn) +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(); } } @@ -1878,17 +2257,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 +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(); } @@ -1896,7 +2275,7 @@ MEDCouplingPointSet *MEDCoupling1DGTUMesh::deepCpyConnectivityOnly() const void MEDCoupling1DGTUMesh::updateTime() const { MEDCoupling1GTUMesh::updateTime(); - const DataArrayInt *c(_conn); + const DataArrayIdType *c(_conn); if(c) updateTimeWith(*c); c=_conn_indx; @@ -1909,19 +2288,15 @@ std::size_t MEDCoupling1DGTUMesh::getHeapMemorySizeWithoutChildren() const return MEDCoupling1GTUMesh::getHeapMemorySizeWithoutChildren(); } -std::vector MEDCoupling1DGTUMesh::getDirectChildren() const +std::vector MEDCoupling1DGTUMesh::getDirectChildrenWithNull() const { - std::vector ret(MEDCoupling1GTUMesh::getDirectChildren()); - const DataArrayInt *c(_conn); - if(c) - ret.push_back(c); - c=_conn_indx; - if(c) - ret.push_back(c); + std::vector ret(MEDCoupling1GTUMesh::getDirectChildrenWithNull()); + ret.push_back((const DataArrayIdType *)_conn); + ret.push_back((const DataArrayIdType *)_conn_indx); return ret; } -MEDCouplingMesh *MEDCoupling1DGTUMesh::deepCpy() const +MEDCoupling1DGTUMesh *MEDCoupling1DGTUMesh::deepCopy() const { return clone(true); } @@ -1939,7 +2314,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) @@ -1949,7 +2324,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; @@ -1962,7 +2337,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; @@ -1977,15 +2352,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) @@ -2011,7 +2378,7 @@ void MEDCoupling1DGTUMesh::checkFastEquivalWith(const MEDCouplingMesh *other, do 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) @@ -2037,9 +2404,9 @@ void MEDCoupling1DGTUMesh::checkFastEquivalWith(const MEDCouplingMesh *other, do } } -void MEDCoupling1DGTUMesh::checkCoherencyOfConnectivity() const +void MEDCoupling1DGTUMesh::checkConsistencyOfConnectivity() const { - const DataArrayInt *c1(_conn); + const DataArrayIdType *c1(_conn); if(c1) { if(c1->getNumberOfComponents()!=1) @@ -2051,7 +2418,7 @@ void MEDCoupling1DGTUMesh::checkCoherencyOfConnectivity() const else throw INTERP_KERNEL::Exception("Nodal connectivity array not defined !"); // - int sz2=_conn->getNumberOfTuples(); + mcIdType sz2(_conn->getNumberOfTuples()); c1=_conn_indx; if(c1) { @@ -2062,8 +2429,8 @@ void MEDCoupling1DGTUMesh::checkCoherencyOfConnectivity() const 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()); @@ -2081,10 +2448,10 @@ void MEDCoupling1DGTUMesh::checkCoherencyOfConnectivity() const } 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()); } } @@ -2094,23 +2461,23 @@ void MEDCoupling1DGTUMesh::checkCoherencyOfConnectivity() const * 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 +void MEDCoupling1DGTUMesh::checkConsistencyLight() const { - MEDCouplingPointSet::checkCoherency(); - checkCoherencyOfConnectivity(); + MEDCouplingPointSet::checkConsistencyLight(); + checkConsistencyOfConnectivity(); } -void MEDCoupling1DGTUMesh::checkCoherency1(double eps) const +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) @@ -2121,14 +2488,9 @@ void MEDCoupling1DGTUMesh::checkCoherency1(double eps) const } } -void MEDCoupling1DGTUMesh::checkCoherency2(double eps) const -{ - checkCoherency1(eps); -} - -int MEDCoupling1DGTUMesh::getNumberOfCells() const +mcIdType MEDCoupling1DGTUMesh::getNumberOfCells() const { - checkCoherencyOfConnectivity();//do not remove + checkConsistencyOfConnectivity();//do not remove return _conn_indx->getNumberOfTuples()-1; } @@ -2140,20 +2502,20 @@ int MEDCoupling1DGTUMesh::getNumberOfCells() const * * \return a newly allocated array */ -DataArrayInt *MEDCoupling1DGTUMesh::computeNbOfNodesPerCell() const +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); @@ -2240,14 +2602,14 @@ void MEDCoupling1DGTUMesh::getNodeIdsOfCell(int cellId, std::vector& conn) } } -int MEDCoupling1DGTUMesh::getNumberOfNodesInCell(int cellId) const +mcIdType MEDCoupling1DGTUMesh::getNumberOfNodesInCell(mcIdType cellId) const { - int nbOfCells(getNumberOfCells());//performs checks + mcIdType nbOfCells=getNumberOfCells();//performs checks if(cellId>=0 && cellIdbegin()); - int strt=_conn_indx->getIJ(cellId,0),stp=_conn_indx->getIJ(cellId+1,0); - return stp-strt-std::count(conn+strt,conn+stp,-1); + const mcIdType *conn(_conn->begin()); + 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 { @@ -2259,6 +2621,8 @@ int MEDCoupling1DGTUMesh::getNumberOfNodesInCell(int cellId) const 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"; @@ -2284,11 +2648,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"; @@ -2307,16 +2671,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," ")); @@ -2327,23 +2691,23 @@ std::string MEDCoupling1DGTUMesh::advancedRepr() const 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()); @@ -2352,7 +2716,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 @@ -2364,13 +2728,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 << " !"; @@ -2402,26 +2766,26 @@ DataArrayDouble *MEDCoupling1DGTUMesh::computeIsoBarycenterOfNodesPerCell() cons return ret.retn(); } -void MEDCoupling1DGTUMesh::renumberCells(const int *old2NewBg, bool check) +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 @@ -2430,12 +2794,11 @@ void MEDCoupling1DGTUMesh::renumberCells(const int *old2NewBg, bool check) 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; @@ -2477,16 +2840,19 @@ MEDCouplingUMesh *MEDCoupling1DGTUMesh::buildUnstructured() const } } 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) +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(); @@ -2494,7 +2860,13 @@ DataArrayInt *MEDCoupling1DGTUMesh::simplexize(int policy) 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 ; } @@ -2503,11 +2875,11 @@ void MEDCoupling1DGTUMesh::reprQuickOverview(std::ostream& stream) const 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() << "."; } @@ -2535,67 +2907,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 { - 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 +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 { - 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 +void MEDCoupling1DGTUMesh::getTinySerializationInformation(std::vector& tinyInfoD, std::vector& tinyInfo, std::vector& littleStrings) const { int it,order; double time=getTime(it,order); @@ -2656,11 +3028,11 @@ void MEDCoupling1DGTUMesh::getTinySerializationInformation(std::vector& std::vector littleStrings2,littleStrings3,littleStrings4; if((const DataArrayDouble *)_coords) _coords->getTinySerializationStrInformation(littleStrings2); - if((const DataArrayInt *)_conn) + if((const DataArrayIdType *)_conn) _conn->getTinySerializationStrInformation(littleStrings3); - if((const DataArrayInt *)_conn_indx) + if((const DataArrayIdType *)_conn_indx) _conn_indx->getTinySerializationStrInformation(littleStrings4); - int sz0((int)littleStrings2.size()),sz1((int)littleStrings3.size()),sz2((int)littleStrings4.size()); + 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()); @@ -2668,14 +3040,14 @@ void MEDCoupling1DGTUMesh::getTinySerializationInformation(std::vector& tinyInfo.push_back(getCellModelEnum()); tinyInfo.push_back(it); tinyInfo.push_back(order); - std::vector tinyInfo2,tinyInfo3,tinyInfo4; + std::vector tinyInfo2,tinyInfo3,tinyInfo4; if((const DataArrayDouble *)_coords) _coords->getTinySerializationIntInformation(tinyInfo2); - if((const DataArrayInt *)_conn) + if((const DataArrayIdType *)_conn) _conn->getTinySerializationIntInformation(tinyInfo3); - if((const DataArrayInt *)_conn_indx) + if((const DataArrayIdType *)_conn_indx) _conn_indx->getTinySerializationIntInformation(tinyInfo4); - int sz3((int)tinyInfo2.size()),sz4((int)tinyInfo3.size()),sz5((int)tinyInfo4.size()); + 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()); @@ -2684,34 +3056,34 @@ void MEDCoupling1DGTUMesh::getTinySerializationInformation(std::vector& tinyInfoD.push_back(time); } -void MEDCoupling1DGTUMesh::resizeForUnserialization(const std::vector& tinyInfo, DataArrayInt *a1, DataArrayDouble *a2, std::vector& littleStrings) const +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]); - MEDCouplingAutoRefCountObjectPtr p1(DataArrayInt::New()); p1->resizeForUnserialization(tinyInfo1); - MEDCouplingAutoRefCountObjectPtr p2(DataArrayInt::New()); p2->resizeForUnserialization(tinyInfo12); - std::vector v(2); v[0]=p1; v[1]=p2; - p2=DataArrayInt::Aggregate(v); + 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(DataArrayInt *&a1, DataArrayDouble *&a2) const +void MEDCoupling1DGTUMesh::serialize(DataArrayIdType *&a1, DataArrayDouble *&a2) const { - int sz(0); - if((const DataArrayInt *)_conn) + mcIdType sz(0); + if((const DataArrayIdType *)_conn) if(_conn->isAllocated()) sz=_conn->getNbOfElems(); - if((const DataArrayInt *)_conn_indx) + if((const DataArrayIdType *)_conn_indx) if(_conn_indx->isAllocated()) sz+=_conn_indx->getNbOfElems(); - a1=DataArrayInt::New(); + a1=DataArrayIdType::New(); a1->alloc(sz,1); - int *work(a1->getPointer()); - if(sz!=0 && (const DataArrayInt *)_conn) + mcIdType *work(a1->getPointer()); + if(sz!=0 && (const DataArrayIdType *)_conn) work=std::copy(_conn->begin(),_conn->end(),a1->getPointer()); - if(sz!=0 && (const DataArrayInt *)_conn_indx) + if(sz!=0 && (const DataArrayIdType *)_conn_indx) std::copy(_conn_indx->begin(),_conn_indx->end(),work); sz=0; if((const DataArrayDouble *)_coords) @@ -2723,27 +3095,27 @@ void MEDCoupling1DGTUMesh::serialize(DataArrayInt *&a1, DataArrayDouble *&a2) co std::copy(_coords->begin(),_coords->end(),a2->getPointer()); } -void MEDCoupling1DGTUMesh::unserialization(const std::vector& tinyInfoD, const std::vector& tinyInfo, const DataArrayInt *a1, DataArrayDouble *a2, +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].c_str()); - setDescription(littleStrings[1].c_str()); - setTimeUnit(littleStrings[2].c_str()); - setTime(tinyInfoD[0],tinyInfo[1],tinyInfo[2]); - int sz0(tinyInfo[3]),sz1(tinyInfo[4]),sz2(tinyInfo[5]),sz3(tinyInfo[6]),sz4(tinyInfo[7]),sz5(tinyInfo[8]); + 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); + std::vector tinyInfo2(tinyInfo.begin()+9,tinyInfo.begin()+9+sz3); _coords->resizeForUnserialization(tinyInfo2); std::copy(a2->begin(),a2->end(),_coords->getPointer()); - _conn=DataArrayInt::New(); - std::vector tinyInfo3(tinyInfo.begin()+9+sz3,tinyInfo.begin()+9+sz3+sz4); + _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=DataArrayInt::New(); - std::vector tinyInfo4(tinyInfo.begin()+9+sz3+sz4,tinyInfo.begin()+9+sz3+sz4+sz5); + _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); @@ -2754,35 +3126,64 @@ void MEDCoupling1DGTUMesh::unserialization(const std::vector& tinyInfoD, _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 +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. @@ -2805,17 +3249,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(); } @@ -2842,26 +3284,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++; @@ -2881,13 +3323,13 @@ void MEDCoupling1DGTUMesh::fillCellIdsToKeepFromNodeIds(const int *begin, const cellIdsKeptArr=cellIdsKept.retn(); } -void MEDCoupling1DGTUMesh::allocateCells(int nbOfCells) +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(); } @@ -2899,19 +3341,19 @@ void MEDCoupling1DGTUMesh::allocateCells(int nbOfCells) * \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) +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 { @@ -2923,7 +3365,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) +void MEDCoupling1DGTUMesh::setNodalConnectivity(DataArrayIdType *nodalConn, DataArrayIdType *nodalConnIndex) { if(nodalConn) nodalConn->incrRef(); @@ -2935,21 +3377,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 +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 +DataArrayIdType *MEDCoupling1DGTUMesh::getNodalConnectivityIndex() const { - const DataArrayInt *ret(_conn_indx); - return const_cast(ret); + const DataArrayIdType *ret(_conn_indx); + return const_cast(ret); } /*! @@ -2967,10 +3409,10 @@ DataArrayInt *MEDCoupling1DGTUMesh::getNodalConnectivityIndex() const */ 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(); @@ -2978,7 +3420,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) @@ -2995,20 +3437,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 +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; @@ -3020,11 +3462,11 @@ 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 { - checkCoherency(); + checkConsistencyLight(); return _conn_indx->front()==0 && _conn_indx->back()==_conn->getNumberOfTuples(); } @@ -3050,17 +3492,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::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; @@ -3102,10 +3544,10 @@ 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(); } @@ -3116,16 +3558,16 @@ MEDCoupling1DGTUMesh *MEDCoupling1DGTUMesh::Merge1DGTUMeshesLL(std::vector > 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++) @@ -3140,22 +3582,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 +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; @@ -3163,7 +3605,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; @@ -3171,7 +3613,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 @@ -3182,31 +3624,33 @@ MEDCoupling1DGTUMesh *MEDCoupling1DGTUMesh::buildSetInstanceFromThis(int spaceDi /*! * 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() const +DataArrayDouble *MEDCoupling1DGTUMesh::getBoundingBoxForBBTree(double arcDetEps) const { checkFullyDefined(); - int spaceDim(getSpaceDimension()),nbOfCells(getNumberOfCells()),nbOfNodes(getNumberOfNodes()); - MEDCouplingAutoRefCountObjectPtr ret(DataArrayDouble::New()); ret->alloc(nbOfCells,2*spaceDim); + mcIdType spaceDim(getSpaceDimension()),nbOfCells(getNumberOfCells()),nbOfNodes(getNumberOfNodes()); + MCAuto ret(DataArrayDouble::New()); ret->alloc(nbOfCells,2*spaceDim); double *bbox(ret->getPointer()); - for(int i=0;i::max(); bbox[2*i+1]=-std::numeric_limits::max(); } const double *coordsPtr(_coords->getConstPointer()); - const int *conn(_conn->getConstPointer()),*connI(_conn_indx->getConstPointer()); - for(int i=0;igetConstPointer()),*connI(_conn_indx->getConstPointer()); + for(mcIdType i=0;i=0 && nodeId MEDCoupling1DGTUMesh::BuildAPolygonFromParts(const std::vector< std::vector >& parts) +/*! + * Returns the cell field giving for each cell in \a this its diameter. Diameter means the max length of all possible SEG2 in the cell. + * + * \return a new instance of field containing the result. The returned instance has to be deallocated by the caller. + */ +MEDCouplingFieldDouble *MEDCoupling1DGTUMesh::computeDiameterField() const +{ + throw INTERP_KERNEL::Exception("MEDCoupling1DGTUMesh::computeDiameterField : not implemented yet for dynamic types !"); +} + +std::vector MEDCoupling1DGTUMesh::BuildAPolygonFromParts(const std::vector< std::vector >& parts) { - std::vector ret; + std::vector ret; if(parts.empty()) return ret; ret.insert(ret.end(),parts[0].begin(),parts[0].end()); - int ref(ret.back()); + mcIdType ref(ret.back()); std::size_t sz(parts.size()),nbh(1); std::vector b(sz,true); b[0]=false; while(nbh MEDCoupling1DGTUMesh::BuildAPolygonFromParts(const std::vector< } /*! - * 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 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 MEDCoupling1DGTUMesh::invertOrientationOfAllCells() +{ + checkConsistencyOfConnectivity(); + INTERP_KERNEL::AutoCppPtr 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) +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 !"); @@ -3280,15 +3751,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