return pfl->getName();
}
+/*!
+ * Returns the number of cells having geometric type \a t.
+ * The profiles are **NOT** taken into account here.
+ */
+int MEDMeshMultiLev::getNumberOfCells(INTERP_KERNEL::NormalizedCellType t) const throw(INTERP_KERNEL::Exception)
+{
+ std::size_t sz(_nb_entities.size());
+ for(std::size_t i=0;i<sz;i++)
+ if(_geo_types[i]==t)
+ return _nb_entities[i];
+ throw INTERP_KERNEL::Exception("MEDMeshMultiLev::getNumberOfCells : not existing geometric type in this !");
+}
+
+int MEDMeshMultiLev::getNumberOfNodes() const throw(INTERP_KERNEL::Exception)
+{
+ return _nb_nodes;
+}
+
DataArray *MEDMeshMultiLev::constructDataArray(const MEDFileField1TSStructItem& fst, const MEDFileFieldGlobsReal *globs, const DataArray *vals) const throw(INTERP_KERNEL::Exception)
{
if(fst.getType()==ON_NODES)
{
MEDCouplingAutoRefCountObjectPtr<DataArrayInt> p1(globs->getProfile(pflName.c_str())->deepCpy());
p1->sort(true);
- if(!p1->isIdentity() || p1->getNumberOfTuples()!=p.getNbEntity())
+ if(!p1->isIdentity() || p1->getNumberOfTuples()!=getNumberOfNodes())
throw INTERP_KERNEL::Exception("MEDMeshMultiLev::constructDataArray : unexpected situation for nodes 4 !");
MEDCouplingAutoRefCountObjectPtr<DataArray> ret(vals->deepCpy());
ret->renumberInPlace(globs->getProfile(pflName.c_str())->begin());
else
{
std::size_t sz(fst.getNumberOfItems());
- std::vector< MEDCouplingAutoRefCountObjectPtr<DataArray> > arrSafe(sz);
- std::vector< const DataArray *> arr(sz);
- for(std::size_t i=0;i<sz;i++)
+ std::set<INTERP_KERNEL::NormalizedCellType> s(_geo_types.begin(),_geo_types.end());
+ if(s.size()!=_geo_types.size())
+ throw INTERP_KERNEL::Exception("MEDMeshMultiLev::constructDataArray : unexpected situation for cells 2 !");
+ std::vector< const DataArray *> arr(s.size());
+ std::vector< MEDCouplingAutoRefCountObjectPtr<DataArray> > arrSafe(s.size());
+ int iii(0);
+ int nc(vals->getNumberOfComponents());
+ std::vector<std::string> compInfo(vals->getInfoOnComponents());
+ for(std::vector< INTERP_KERNEL::NormalizedCellType >::const_iterator it=_geo_types.begin();it!=_geo_types.end();it++,iii++)
{
- const MEDFileField1TSStructItem2& p(fst[i]);
- const std::pair<int,int>& strtStop(p.getStartStop());
- std::vector< INTERP_KERNEL::NormalizedCellType >::const_iterator it(std::find(_geo_types.begin(),_geo_types.end(),p.getGeo()));
- if(it==_geo_types.end())
- throw INTERP_KERNEL::Exception("MEDMeshMultiLev::constructDataArray : unexpected situation for cells 1 !");
- if(std::find(it+1,_geo_types.end(),p.getGeo())!=_geo_types.end())
- throw INTERP_KERNEL::Exception("MEDMeshMultiLev::constructDataArray : unexpected situation for cells 2 !");
- std::size_t pos(std::distance(_geo_types.begin(),it));
- const DataArrayInt *thisP(_pfls[pos]),*otherP(p.getPfl(globs));
- MEDCouplingAutoRefCountObjectPtr<DataArray> ret(vals->selectByTupleId2(strtStop.first,strtStop.second,1));
- if(!thisP && !otherP)
+ const DataArrayInt *thisP(_pfls[iii]);
+ std::vector<const MEDFileField1TSStructItem2 *> ps;
+ for(std::size_t i=0;i<sz;i++)
{
- arrSafe[i]=ret; arr[i]=ret;
- continue;
- }
- int nbi(p.getNbOfIntegrationPts(globs)),nc(ret->getNumberOfComponents());
- if(!thisP && otherP)
- {
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> p1(otherP->deepCpy());
- p1->sort(true);
- if(!p1->isIdentity() || p1->getNumberOfTuples()!=p.getNbEntity())
- throw INTERP_KERNEL::Exception("MEDMeshMultiLev::constructDataArray : unexpected situation for cells 3 !");
- ret->rearrange(nbi*nc); ret->renumberInPlace(otherP->begin()); ret->rearrange(nc);
- arrSafe[i]=ret; arr[i]=ret;
- continue;
+ const MEDFileField1TSStructItem2& p(fst[i]);
+ if(p.getGeo()==*it)
+ ps.push_back(&p);
}
- if(thisP && otherP)
+ if(ps.empty())
+ throw INTERP_KERNEL::Exception("MEDMeshMultiLev::constructDataArray : unexpected situation for cells 1 !");
+ if(ps.size()==1)
{
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> p1(otherP->deepCpy());
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> p2(thisP->deepCpy());
- p1->sort(true); p2->sort(true);
- if(!p1->isEqualWithoutConsideringStr(*p2))
- throw INTERP_KERNEL::Exception("MEDMeshMultiLev::constructDataArray : unexpected situation for cells 4 !");
- p1=DataArrayInt::FindPermutationFromFirstToSecond(otherP,thisP);
- ret->rearrange(nbi*nc); ret->renumberInPlace(p1->begin()); ret->rearrange(nc);
- continue;
+ int nbi(ps[0]->getNbOfIntegrationPts(globs));
+ const DataArrayInt *otherP(ps[0]->getPfl(globs));
+ const std::pair<int,int>& strtStop(ps[0]->getStartStop());
+ MEDCouplingAutoRefCountObjectPtr<DataArray> ret(vals->selectByTupleId2(strtStop.first,strtStop.second,1));
+ if(!thisP && !otherP)
+ {
+ arrSafe[iii]=ret; arr[iii]=ret;
+ continue;
+ }
+ if(thisP && otherP)
+ {
+ MEDCouplingAutoRefCountObjectPtr<DataArrayInt> p1(otherP->invertArrayN2O2O2N(getNumberOfCells(ps[0]->getGeo())));
+ MEDCouplingAutoRefCountObjectPtr<DataArrayInt> p2(thisP->deepCpy());
+ p2->transformWithIndArr(p1->begin(),p1->end());
+ //p1=p2->getIdsNotEqual(-1);
+ //p1=p2->selectByTupleIdSafe(p1->begin(),p1->end());
+ ret->rearrange(nbi*nc); ret=ret->selectByTupleIdSafe(p2->begin(),p2->end()); ret->rearrange(nc); ret->setInfoOnComponents(compInfo);
+ arrSafe[iii]=ret; arr[iii]=ret;
+ continue;
+ }
+ if(!thisP && otherP)
+ {
+ MEDCouplingAutoRefCountObjectPtr<DataArrayInt> p1(otherP->deepCpy());
+ p1->sort(true);
+ p1->checkAllIdsInRange(0,getNumberOfCells(ps[0]->getGeo()));
+ p1=DataArrayInt::FindPermutationFromFirstToSecond(otherP,p1);
+ ret->rearrange(nbi*nc); ret->renumberInPlace(p1->begin()); ret->rearrange(nc); ret->setInfoOnComponents(compInfo);
+ arrSafe[iii]=ret; arr[iii]=ret;
+ continue;
+ }
+ throw INTERP_KERNEL::Exception("MEDMeshMultiLev::constructDataArray : unexpected situation for cells 3 !");
}
- if(thisP && !otherP)
+ else
{
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> p1(thisP->deepCpy());
- p1->sort(true);
- if(!p1->isIdentity() || p1->getNumberOfTuples()!=p.getNbEntity())
- throw INTERP_KERNEL::Exception("MEDMeshMultiLev::constructDataArray : unexpected situation for cells 3 !");
- ret->rearrange(nbi*nc); ret->renumberInPlaceR(otherP->begin()); ret->rearrange(nc);
- arrSafe[i]=ret; arr[i]=ret;
+ std::vector< const DataArrayInt * >otherPS(ps.size());
+ std::vector< const DataArray * > arr2(ps.size());
+ std::vector< MEDCouplingAutoRefCountObjectPtr<DataArray> > arr2Safe(ps.size());
+ std::vector< const DataArrayInt * > nbis(ps.size());
+ std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > nbisSafe(ps.size());
+ int jj(0);
+ for(std::vector<const MEDFileField1TSStructItem2 *>::const_iterator it2=ps.begin();it2!=ps.end();it2++,jj++)
+ {
+ int nbi((*it2)->getNbOfIntegrationPts(globs));
+ const DataArrayInt *otherPfl((*it2)->getPfl(globs));
+ const std::pair<int,int>& strtStop((*it2)->getStartStop());
+ MEDCouplingAutoRefCountObjectPtr<DataArray> ret2(vals->selectByTupleId2(strtStop.first,strtStop.second,1));
+ if(!otherPfl)
+ throw INTERP_KERNEL::Exception("MEDMeshMultiLev::constructDataArray : unexpected situation for cells 4 !");
+ arr2[jj]=ret2; arr2Safe[jj]=ret2; otherPS[jj]=otherPfl;
+ nbisSafe[jj]=DataArrayInt::New(); nbisSafe[jj]->alloc(otherPfl->getNumberOfTuples(),1); nbisSafe[jj]->fillWithValue(nbi);
+ nbis[jj]=nbisSafe[jj];
+ }
+ MEDCouplingAutoRefCountObjectPtr<DataArray> arr3(DataArray::Aggregate(arr2));
+ MEDCouplingAutoRefCountObjectPtr<DataArrayInt> otherP(DataArrayInt::Aggregate(otherPS));
+ MEDCouplingAutoRefCountObjectPtr<DataArrayInt> zenbis(DataArrayInt::Aggregate(nbis));
+ MEDCouplingAutoRefCountObjectPtr<DataArrayInt> otherPN(otherP->invertArrayN2O2O2N(getNumberOfCells(*it)));
+ MEDCouplingAutoRefCountObjectPtr<DataArrayInt> p1;
+ if(thisP)
+ p1=DataArrayInt::FindPermutationFromFirstToSecond(otherP,thisP);
+ else
+ p1=otherP->deepCpy();
+ MEDCouplingAutoRefCountObjectPtr<DataArrayInt> zenbisN(zenbis->renumber(p1->begin()));
+ zenbisN->computeOffsets2();
+ jj=0;
+ for(std::vector<const MEDFileField1TSStructItem2 *>::const_iterator it2=ps.begin();it2!=ps.end();it2++,jj++)
+ {
+ int nbi((*it2)->getNbOfIntegrationPts(globs));
+ const DataArrayInt *otherPfl((*it2)->getPfl(globs));
+ const std::pair<int,int>& strtStop((*it2)->getStartStop());
+ MEDCouplingAutoRefCountObjectPtr<DataArray> ret2(vals->selectByTupleId2(strtStop.first,strtStop.second,1));
+ //
+ MEDCouplingAutoRefCountObjectPtr<DataArrayInt> p2(otherPfl->deepCpy());
+ p2->transformWithIndArr(otherPN->begin(),otherPN->end());
+ p2->transformWithIndArr(p1->begin(),p1->end());
+ MEDCouplingAutoRefCountObjectPtr<DataArrayInt> idsN(p2->buildExplicitArrByRanges(zenbisN));
+ arr3->setPartOfValuesBase3(ret2,idsN->begin(),idsN->end(),0,nc,1);
+ }
+ arrSafe[iii]=arr3; arr[iii]=arr3;
continue;
}
- throw INTERP_KERNEL::Exception("MEDMeshMultiLev::constructDataArray : unexpected situation for cells 6 !");
}
return DataArray::Aggregate(arr);
}
{
}
-MEDMeshMultiLev::MEDMeshMultiLev(const std::vector<INTERP_KERNEL::NormalizedCellType>& gts, const std::vector<const DataArrayInt *>& pfls, const std::vector<int>& nbEntities):_geo_types(gts),_nb_entities(nbEntities)
+MEDMeshMultiLev::MEDMeshMultiLev(int nbNodes, const std::vector<INTERP_KERNEL::NormalizedCellType>& gts, const std::vector<const DataArrayInt *>& pfls, const std::vector<int>& nbEntities):_geo_types(gts),_nb_entities(nbEntities),_nb_nodes(nbNodes)
{
std::size_t sz(_geo_types.size());
if(sz!=pfls.size() || sz!=nbEntities.size())
}
}
-MEDMeshMultiLev::MEDMeshMultiLev(const MEDMeshMultiLev& other):_pfls(other._pfls),_geo_types(other._geo_types),_nb_entities(other._nb_entities),_node_reduction(other._node_reduction)
+MEDMeshMultiLev::MEDMeshMultiLev(const MEDMeshMultiLev& other):_pfls(other._pfls),_geo_types(other._geo_types),_nb_entities(other._nb_entities),_node_reduction(other._node_reduction),_nb_nodes(other._nb_nodes)
{
}
return new MEDUMeshMultiLev(m,gts,pfls,nbEntities);
}
-MEDUMeshMultiLev::MEDUMeshMultiLev(const MEDFileUMesh *m, const std::vector<INTERP_KERNEL::NormalizedCellType>& gts, const std::vector<const DataArrayInt *>& pfls, const std::vector<int>& nbEntities):MEDMeshMultiLev(gts,pfls,nbEntities)
+MEDUMeshMultiLev::MEDUMeshMultiLev(const MEDFileUMesh *m, const std::vector<INTERP_KERNEL::NormalizedCellType>& gts, const std::vector<const DataArrayInt *>& pfls, const std::vector<int>& nbEntities):MEDMeshMultiLev(m->getNumberOfNodes(),gts,pfls,nbEntities)
{
std::size_t sz(gts.size());
_parts.resize(sz);
MEDCouplingAutoRefCountObjectPtr<DataArrayInt> cellIdsSafe(cellIds);
MEDCouplingAutoRefCountObjectPtr<MEDCouplingPointSet> m2(m->buildPartOfMySelfKeepCoords(cellIds->begin(),cellIds->end()));
int tmp=-1;
- a[i]=m2->getNodeIdsInUse(tmp); aa[i]=a[i];
+ MEDCouplingAutoRefCountObjectPtr<DataArrayInt> o2n(m2->getNodeIdsInUse(tmp));
+ a[i]=o2n->invertArrayO2N2N2O(tmp); aa[i]=a[i];
if(pfl)
_pfls[i]=pfl->selectByTupleIdSafe(cellIds->begin(),cellIds->end());
else
{
_parts.resize(1);
_parts[0]=part;
+ _geo_types.resize(1); _geo_types[0]=part->getCellModelEnum();
+ _nb_entities.resize(1); _nb_entities[0]=part->getNumberOfCells();
+ _pfls.resize(1); _pfls[0]=0;
}
void MEDUMeshMultiLev::buildVTUArrays(DataArrayDouble *& coords, DataArrayByte *&types, DataArrayInt *&cellLocations, DataArrayInt *& cells, DataArrayInt *&faceLocations, DataArrayInt *&faces) const throw(INTERP_KERNEL::Exception)
MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> a(const_cast<DataArrayDouble *>(tmp)); tmp->incrRef();
int szBCE(0),szD(0),szF(0);
bool isPolyh(false);
- for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDCoupling1GTUMesh> >::const_iterator it=_parts.begin();it!=_parts.end();it++)
+ int iii(0);
+ for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDCoupling1GTUMesh> >::const_iterator it=_parts.begin();it!=_parts.end();it++,iii++)
{
const MEDCoupling1GTUMesh *cur(*it);
if(!cur)
throw INTERP_KERNEL::Exception("MEDUMeshMultiLev::getVTUArrays : a part is null !");
+ //
+ const DataArrayInt *pfl(_pfls[iii]);
+ MEDCouplingAutoRefCountObjectPtr<MEDCoupling1GTUMesh> cur2;
+ if(!pfl)
+ { cur2=const_cast<MEDCoupling1GTUMesh *>(cur); cur2->incrRef(); }
+ else
+ { cur2=dynamic_cast<MEDCoupling1GTUMesh *>(cur->buildPartOfMySelfKeepCoords(pfl->begin(),pfl->end())); cur=cur2; }
+ //
int curNbCells(cur->getNumberOfCells());
szBCE+=curNbCells;
if((*it)->getCellModelEnum()!=INTERP_KERNEL::NORM_POLYHED)
- szD+=(*it)->getNodalConnectivity()->getNumberOfTuples()+curNbCells;
+ szD+=cur->getNodalConnectivity()->getNumberOfTuples()+curNbCells;
else
{
isPolyh=true;
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmp((*it)->computeEffectiveNbOfNodesPerCell());
+ MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmp(cur->computeEffectiveNbOfNodesPerCell());
szD+=tmp->accumulate(0)+curNbCells;
- szF+=2*curNbCells+(*it)->getNodalConnectivity()->getNumberOfTuples();
+ szF+=2*curNbCells+cur->getNodalConnectivity()->getNumberOfTuples();
}
}
MEDCouplingAutoRefCountObjectPtr<DataArrayByte> b(DataArrayByte::New()); b->alloc(szBCE,1); char *bPtr(b->getPointer());
if(isPolyh)
{ e->alloc(szBCE,1); ePtr=e->getPointer(); f->alloc(szF,1); fPtr=f->getPointer(); }
int k(0);
- for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDCoupling1GTUMesh> >::const_iterator it=_parts.begin();it!=_parts.end();it++)
+ iii=0;
+ for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDCoupling1GTUMesh> >::const_iterator it=_parts.begin();it!=_parts.end();it++,iii++)
{
const MEDCoupling1GTUMesh *cur(*it);
+ //
+ const DataArrayInt *pfl(_pfls[iii]);
+ MEDCouplingAutoRefCountObjectPtr<MEDCoupling1GTUMesh> cur2;
+ if(!pfl)
+ { cur2=const_cast<MEDCoupling1GTUMesh *>(cur); cur2->incrRef(); }
+ else
+ { cur2=dynamic_cast<MEDCoupling1GTUMesh *>(cur->buildPartOfMySelfKeepCoords(pfl->begin(),pfl->end())); cur=cur2; }
+ //
int curNbCells(cur->getNumberOfCells());
int gt((int)cur->getCellModelEnum());
if(gt<0 || gt>=PARAMEDMEM_2_VTKTYPE_LGTH)
{
for(int i=0;i<curNbCells;i++,connIPtr++)
{
- std::set<int> s(connPtr+connIPtr[0],connPtr+connIPtr[1]);
+ std::set<int> s(connPtr+connIPtr[0],connPtr+connIPtr[1]); s.erase(-1);
*dPtr++=(int)s.size();
dPtr=std::copy(s.begin(),s.end(),dPtr);
*cPtr=k+(int)s.size(); k=*cPtr++;
fPtr=std::copy(work,work2,fPtr);
work=work2+1;
}
- *ePtr=kk; kk+=connIPtr[1]-connIPtr[0]+2;
+ *ePtr++=kk; kk+=connIPtr[1]-connIPtr[0]+2;
}
}
}
{ faceLocations=e.retn(); faces=f.retn(); }
}
-void MEDUMeshMultiLev::reorderNodesIfNecessary(DataArrayDouble *coords, DataArrayInt *nodalConnVTK, DataArrayInt *polyhedNodalConnVTK) const throw(INTERP_KERNEL::Exception)
+void MEDUMeshMultiLev::reorderNodesIfNecessary(MEDCouplingAutoRefCountObjectPtr<DataArrayDouble>& coords, DataArrayInt *nodalConnVTK, DataArrayInt *polyhedNodalConnVTK) const throw(INTERP_KERNEL::Exception)
{
const DataArrayInt *nr(_node_reduction);
if(!nr)
}
}
}
- MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> coo(coords->selectByTupleIdSafe(nr->begin(),nr->end()));
- coords->cpyFrom(*coo);
+ coords=(coords->selectByTupleIdSafe(nr->begin(),nr->end()));
}
//=
{
}
-MEDStructuredMeshMultiLev::MEDStructuredMeshMultiLev(const std::vector<INTERP_KERNEL::NormalizedCellType>& gts, const std::vector<const DataArrayInt *>& pfls, const std::vector<int>& nbEntities):MEDMeshMultiLev(gts,pfls,nbEntities)
+MEDStructuredMeshMultiLev::MEDStructuredMeshMultiLev(int nbOfNodes, const std::vector<INTERP_KERNEL::NormalizedCellType>& gts, const std::vector<const DataArrayInt *>& pfls, const std::vector<int>& nbEntities):MEDMeshMultiLev(nbOfNodes,gts,pfls,nbEntities)
{
}
}
}
-MEDCMeshMultiLev::MEDCMeshMultiLev(const MEDFileCMesh *m, const std::vector<INTERP_KERNEL::NormalizedCellType>& gts, const std::vector<const DataArrayInt *>& pfls, const std::vector<int>& nbEntities):MEDStructuredMeshMultiLev(gts,pfls,nbEntities)
+MEDCMeshMultiLev::MEDCMeshMultiLev(const MEDFileCMesh *m, const std::vector<INTERP_KERNEL::NormalizedCellType>& gts, const std::vector<const DataArrayInt *>& pfls, const std::vector<int>& nbEntities):MEDStructuredMeshMultiLev(m->getNumberOfNodes(),gts,pfls,nbEntities)
{
if(!m)
throw INTERP_KERNEL::Exception("MEDCMeshMultiLev constructor 2 : null input pointer !");
if(gts.size()!=1 || pfls.size()!=1)
throw INTERP_KERNEL::Exception("MEDCMeshMultiLev constructor 2 : lengthes of gts and pfls must be equal to one !");
- int mdim(MEDCouplingStructuredMesh::GetGeoTypeGivenMeshDimension(m->getMeshDimension()));
- if(mdim!=gts[0])
+ int mdim(m->getMeshDimension());
+ INTERP_KERNEL::NormalizedCellType gt(MEDCouplingStructuredMesh::GetGeoTypeGivenMeshDimension(mdim));
+ if(gt!=gts[0])
throw INTERP_KERNEL::Exception("MEDCMeshMultiLev constructor 2 : the unique geo type is invalid regarding meshdim !");
_coords.resize(mdim);
for(int i=0;i<mdim;i++)
DataArrayDouble *elt(const_cast<DataArrayDouble *>(m->getMesh()->getCoordsAt(i)));
if(!elt)
throw INTERP_KERNEL::Exception("MEDCMeshMultiLev constructor 2 : presence of null pointer for an vector of double along an axis !");
- _coords[i]=elt;
+ _coords[i]=elt; _coords[i]->incrRef();
}
}
-MEDCMeshMultiLev::MEDCMeshMultiLev(const MEDCMeshMultiLev& other):MEDStructuredMeshMultiLev(other)
+MEDCMeshMultiLev::MEDCMeshMultiLev(const MEDCMeshMultiLev& other):MEDStructuredMeshMultiLev(other),_coords(other._coords)
{
}
_structure=m->getMesh()->getNodeGridStructure();
}
-MEDCurveLinearMeshMultiLev::MEDCurveLinearMeshMultiLev(const MEDFileCurveLinearMesh *m, const std::vector<INTERP_KERNEL::NormalizedCellType>& gts, const std::vector<const DataArrayInt *>& pfls, const std::vector<int>& nbEntities):MEDStructuredMeshMultiLev(gts,pfls,nbEntities)
+MEDCurveLinearMeshMultiLev::MEDCurveLinearMeshMultiLev(const MEDFileCurveLinearMesh *m, const std::vector<INTERP_KERNEL::NormalizedCellType>& gts, const std::vector<const DataArrayInt *>& pfls, const std::vector<int>& nbEntities):MEDStructuredMeshMultiLev(m->getNumberOfNodes(),gts,pfls,nbEntities)
{
if(!m)
throw INTERP_KERNEL::Exception("MEDCurveLinearMeshMultiLev constructor 2 : null input pointer !");
