-// Copyright (C) 2007-2014 CEA/DEN, EDF R&D
+// Copyright (C) 2007-2015 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
#include "MEDFileField.hxx"
#include "MEDFileMesh.hxx"
+#include "MEDCouplingFieldDiscretization.hxx"
#include "CellModel.hxx"
using namespace ParaMEDMEM;
const unsigned char MEDMeshMultiLev::PARAMEDMEM_2_VTKTYPE[MEDMeshMultiLev::PARAMEDMEM_2_VTKTYPE_LGTH]=
- {1,3,21,5,9,7,22,34,23,28,255,255,255,255,10,14,13,255,12,255,24,255,16,27,255,26,255,29,255,255,25,42,36,4};
+{1,3,21,5,9,7,22,34,23,28,255,255,255,255,10,14,13,255,12,255,24,255,16,27,255,26,255,29,255,255,25,42,36,4};
const unsigned char MEDMeshMultiLev::HEXA27_PERM_ARRAY[27]={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,24,22,21,23,20,25,26};
return ret;
}
-std::vector<const BigMemoryObject *> MEDFileMeshStruct::getDirectChildren() const
+std::vector<const BigMemoryObject *> MEDFileMeshStruct::getDirectChildrenWithNull() const
{
return std::vector<const BigMemoryObject *>();
}
return 0;
}
-std::vector<const BigMemoryObject *> MEDMeshMultiLev::getDirectChildren() const
+std::vector<const BigMemoryObject *> MEDMeshMultiLev::getDirectChildrenWithNull() const
{
return std::vector<const BigMemoryObject *>();
}
_node_reduction=const_cast<DataArrayInt*>(nr);
}
+void MEDMeshMultiLev::setCellReduction(const DataArrayInt *cr)
+{
+ if(_pfls.size()!=1)
+ throw INTERP_KERNEL::Exception("MEDMeshMultiLev::setCellReduction : can be used only for single geo type mesh !");
+ _pfls[0]=const_cast<DataArrayInt*>(cr);
+ if(cr)
+ cr->incrRef();
+}
+
bool MEDMeshMultiLev::isFastlyTheSameStruct(const MEDFileField1TSStructItem& fst, const MEDFileFieldGlobsReal *globs) const
{
if(fst.getType()==ON_NODES)
presenceOfPfls=true;
}
if(!presenceOfPfls)
- { famIds=const_cast<DataArrayInt *>(fids); famIds->incrRef(); isWithoutCopy=_cell_fam_ids_nocpy; return ; }
+ { famIds=const_cast<DataArrayInt *>(fids); famIds->incrRef(); isWithoutCopy=_mesh->isObjectInTheProgeny(famIds); return ; }
//bad luck the slowest part
isWithoutCopy=false;
std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > retSafe(sz);
presenceOfPfls=true;
}
if(!presenceOfPfls)
- { numIds=const_cast<DataArrayInt *>(nids); numIds->incrRef(); isWithoutCopy=_cell_num_ids_nocpy; return ; }
+ { numIds=const_cast<DataArrayInt *>(nids); numIds->incrRef(); isWithoutCopy=_mesh->isObjectInTheProgeny(numIds); return ; }
//bad luck the slowest part
isWithoutCopy=false;
std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > retSafe(sz);
}
else
{
- isWithoutCopy=_node_fam_ids_nocpy;
famIds=const_cast<DataArrayInt *>(fids); famIds->incrRef();
+ isWithoutCopy=_mesh->isObjectInTheProgeny(famIds);
}
}
}
else
{
- isWithoutCopy=_node_num_ids_nocpy;
numIds=const_cast<DataArrayInt *>(fids); numIds->incrRef();
+ isWithoutCopy=_mesh->isObjectInTheProgeny(numIds);
}
}
return _geo_types;
}
-void MEDMeshMultiLev::setFamilyIdsOnCells(DataArrayInt *famIds, bool isNoCopy)
+void MEDMeshMultiLev::setFamilyIdsOnCells(DataArrayInt *famIds)
{
_cell_fam_ids=famIds;
if(famIds)
famIds->incrRef();
- _cell_fam_ids_nocpy=isNoCopy;
}
-void MEDMeshMultiLev::setNumberIdsOnCells(DataArrayInt *numIds, bool isNoCopy)
+void MEDMeshMultiLev::setNumberIdsOnCells(DataArrayInt *numIds)
{
_cell_num_ids=numIds;
if(numIds)
numIds->incrRef();
- _cell_num_ids_nocpy=isNoCopy;
}
-void MEDMeshMultiLev::setFamilyIdsOnNodes(DataArrayInt *famIds, bool isNoCopy)
+void MEDMeshMultiLev::setFamilyIdsOnNodes(DataArrayInt *famIds)
{
_node_fam_ids=famIds;
if(famIds)
famIds->incrRef();
- _node_fam_ids_nocpy=isNoCopy;
}
-void MEDMeshMultiLev::setNumberIdsOnNodes(DataArrayInt *numIds, bool isNoCopy)
+void MEDMeshMultiLev::setNumberIdsOnNodes(DataArrayInt *numIds)
{
_node_num_ids=numIds;
if(numIds)
numIds->incrRef();
- _node_num_ids_nocpy=isNoCopy;
}
std::string MEDMeshMultiLev::getPflNameOfId(int id) const
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];
+ return _nb_entities[i];
throw INTERP_KERNEL::Exception("MEDMeshMultiLev::getNumberOfCells : not existing geometric type in this !");
}
if(pflName.empty() && !nr)
return vals->deepCpy();
if(pflName.empty() && nr)
- throw INTERP_KERNEL::Exception("MEDMeshMultiLev::constructDataArray : unexpected situation for nodes 2 !");
+ throw INTERP_KERNEL::Exception("MEDMeshMultiLev::constructDataArray : unexpected situation for nodes 2 !");
if(!pflName.empty() && nr)
{
MEDCouplingAutoRefCountObjectPtr<DataArrayInt> p1(globs->getProfile(pflName.c_str())->deepCpy());
}
a[1]=tmp;
_cell_fam_ids=DataArrayInt::Aggregate(a);
- _cell_fam_ids_nocpy=false;
}
if(cn)
{
}
a[1]=tmp;
_cell_num_ids=DataArrayInt::Aggregate(a);
- _cell_num_ids_nocpy=false;
}
}
-MEDMeshMultiLev::MEDMeshMultiLev(const MEDFileMesh *mesh):_mesh(mesh),_nb_nodes(0),_cell_fam_ids_nocpy(false)
+MEDMeshMultiLev::MEDMeshMultiLev(const MEDFileMesh *mesh):_mesh(mesh),_nb_nodes(0)
{
}
-MEDMeshMultiLev::MEDMeshMultiLev(const MEDFileMesh *mesh, int nbNodes, const std::vector<INTERP_KERNEL::NormalizedCellType>& gts, const std::vector<const DataArrayInt *>& pfls, const std::vector<int>& nbEntities):_mesh(mesh),_geo_types(gts),_nb_entities(nbEntities),_nb_nodes(nbNodes),_cell_fam_ids_nocpy(false),_cell_num_ids_nocpy(false),_node_fam_ids_nocpy(false),_node_num_ids_nocpy(false)
+MEDMeshMultiLev::MEDMeshMultiLev(const MEDFileMesh *mesh, int nbNodes, const std::vector<INTERP_KERNEL::NormalizedCellType>& gts, const std::vector<const DataArrayInt *>& pfls, const std::vector<int>& nbEntities):_mesh(mesh),_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):RefCountObject(other),_mesh(other._mesh),_pfls(other._pfls),_geo_types(other._geo_types),_nb_entities(other._nb_entities),_node_reduction(other._node_reduction),_nb_nodes(other._nb_nodes),_cell_fam_ids(other._cell_fam_ids),_cell_fam_ids_nocpy(other._cell_fam_ids_nocpy),_cell_num_ids(other._cell_num_ids),_cell_num_ids_nocpy(other._cell_num_ids_nocpy),_node_fam_ids(other._node_fam_ids),_node_fam_ids_nocpy(other._node_fam_ids_nocpy),_node_num_ids(other._node_num_ids),_node_num_ids_nocpy(other._node_num_ids_nocpy)
+MEDMeshMultiLev::MEDMeshMultiLev(const MEDMeshMultiLev& other):RefCountObject(other),_mesh(other._mesh),_pfls(other._pfls),_geo_types(other._geo_types),_nb_entities(other._nb_entities),_node_reduction(other._node_reduction),_nb_nodes(other._nb_nodes),_cell_fam_ids(other._cell_fam_ids),_cell_num_ids(other._cell_num_ids),_node_fam_ids(other._node_fam_ids),_node_num_ids(other._node_num_ids)
{
}
_nb_entities[i]=obj->getNumberOfCells();
}
// ids fields management
- _cell_fam_ids_nocpy=(levs.size()==1);
- if(_cell_fam_ids_nocpy)
+ bool cellFamIdsNoCpy(levs.size()==1);
+ if(cellFamIdsNoCpy)
{
const DataArrayInt *tmp(m->getFamilyFieldAtLevel(levs[0]));
if(tmp)
if(f && !tmps.empty())
_cell_fam_ids=DataArrayInt::Aggregate(tmps);
}
- _cell_num_ids_nocpy=(levs.size()==1);
- if(_cell_num_ids_nocpy)
+ bool cellNumIdsNoCpy(levs.size()==1);
+ if(cellNumIdsNoCpy)
{
const DataArrayInt *tmp(m->getNumberFieldAtLevel(levs[0]));
if(tmp)
_cell_num_ids=DataArrayInt::Aggregate(tmps);
}
// node part
- _node_fam_ids_nocpy=true;
{
const DataArrayInt *tmp(m->getFamilyFieldAtLevel(1));
if(tmp)
_node_fam_ids=(const_cast<DataArrayInt *>(tmp));
}
}
- _node_num_ids_nocpy=true;
{
const DataArrayInt *tmp(m->getNumberFieldAtLevel(1));
if(tmp)
int lev((int)dim-m->getMeshDimension());
if(isSameDim && isNoPfl && m->getGeoTypesAtLevel(lev)==gts)//optimized part
{
- _cell_fam_ids_nocpy=true;
const DataArrayInt *famIds(m->getFamilyFieldAtLevel(lev));
if(famIds)
{ _cell_fam_ids=const_cast<DataArrayInt*>(famIds); famIds->incrRef(); }
- _cell_num_ids_nocpy=true;
const DataArrayInt *numIds(m->getNumberFieldAtLevel(lev));
if(numIds)
{ _cell_num_ids=const_cast<DataArrayInt*>(numIds); numIds->incrRef(); }
- _node_fam_ids_nocpy=true;
famIds=m->getFamilyFieldAtLevel(1);
if(famIds)
{ _node_fam_ids=const_cast<DataArrayInt*>(famIds); famIds->incrRef(); }
- _node_num_ids_nocpy=true;
numIds=m->getNumberFieldAtLevel(1);
if(numIds)
{ _node_num_ids=const_cast<DataArrayInt*>(numIds); numIds->incrRef(); }
return ;
}
//
- _cell_fam_ids_nocpy=false;
std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > famIdsSafe(sz);
std::vector<const DataArrayInt *> famIds(sz);
bool f(true);
}
if(f)
_cell_fam_ids=DataArrayInt::Aggregate(famIds);
- _cell_num_ids_nocpy=false;
std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > numIdsSafe(sz);
std::vector<const DataArrayInt *> numIds(sz);
bool n(true);
if(n)
_cell_num_ids=DataArrayInt::Aggregate(numIds);
// node ids management
- _node_fam_ids_nocpy=true;
const DataArrayInt *nodeFamIds(m->getFamilyFieldAtLevel(1));
if(nodeFamIds)
{ _node_fam_ids=const_cast<DataArrayInt*>(nodeFamIds); nodeFamIds->incrRef(); }
- _node_num_ids_nocpy=true;
const DataArrayInt *nodeNumIds(m->getNumberFieldAtLevel(1));
if(nodeNumIds)
{ _node_num_ids=const_cast<DataArrayInt*>(nodeNumIds); nodeNumIds->incrRef(); }
void MEDUMeshMultiLev::selectPartOfNodes(const DataArrayInt *pflNodes)
{
- if(!pflNodes || !pflNodes->isAllocated())
- return ;
- std::size_t sz(_parts.size());
- std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > a(sz);
- std::vector< const DataArrayInt *> aa(sz);
- for(std::size_t i=0;i<sz;i++)
- {
- const DataArrayInt *pfl(_pfls[i]);
- MEDCouplingAutoRefCountObjectPtr<MEDCoupling1GTUMesh> m(_parts[i]);
- if(pfl)
- m=dynamic_cast<MEDCoupling1GTUMesh *>(_parts[i]->buildPartOfMySelfKeepCoords(pfl->begin(),pfl->end()));
- DataArrayInt *cellIds=0;
- m->fillCellIdsToKeepFromNodeIds(pflNodes->begin(),pflNodes->end(),true,cellIds);
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> cellIdsSafe(cellIds);
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingPointSet> m2(m->buildPartOfMySelfKeepCoords(cellIds->begin(),cellIds->end()));
- int tmp=-1;
- 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
- _pfls[i]=cellIdsSafe;
- }
- if(!aa.empty())
- _node_reduction=DataArrayInt::Aggregate(aa);//general case
- else
- _node_reduction=pflNodes->deepCpy();//case where no cells in read mesh.
- _node_reduction->sort(true);
- _node_reduction=_node_reduction->buildUnique();
- if(_node_reduction->getNumberOfTuples()==pflNodes->getNumberOfTuples())
- return ;//This is the classical case where the input node profile corresponds perfectly to a subset of cells in _parts
- if(_node_reduction->getNumberOfTuples()>pflNodes->getNumberOfTuples())
- throw INTERP_KERNEL::Exception("MEDUMeshMultiLev::selectPartOfNodes : internal error in MEDCoupling during cell select from a list of nodes !");
- // Here the cells available in _parts is not enough to cover all the nodes in pflNodes. So adding vertices cells in _parts...
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> pflNodes2(pflNodes->deepCpy());
- pflNodes2->sort(true);
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> diff(pflNodes2->buildSubstractionOptimized(_node_reduction));
- appendVertices(diff,pflNodes2);
+ if(!pflNodes || !pflNodes->isAllocated())
+ return ;
+ std::size_t sz(_parts.size());
+ std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > a(sz);
+ std::vector< const DataArrayInt *> aa(sz);
+ for(std::size_t i=0;i<sz;i++)
+ {
+ const DataArrayInt *pfl(_pfls[i]);
+ MEDCouplingAutoRefCountObjectPtr<MEDCoupling1GTUMesh> m(_parts[i]);
+ if(pfl)
+ m=dynamic_cast<MEDCoupling1GTUMesh *>(_parts[i]->buildPartOfMySelfKeepCoords(pfl->begin(),pfl->end()));
+ DataArrayInt *cellIds=0;
+ m->fillCellIdsToKeepFromNodeIds(pflNodes->begin(),pflNodes->end(),true,cellIds);
+ MEDCouplingAutoRefCountObjectPtr<DataArrayInt> cellIdsSafe(cellIds);
+ MEDCouplingAutoRefCountObjectPtr<MEDCouplingPointSet> m2(m->buildPartOfMySelfKeepCoords(cellIds->begin(),cellIds->end()));
+ int tmp=-1;
+ 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
+ _pfls[i]=cellIdsSafe;
+ }
+ if(!aa.empty())
+ _node_reduction=DataArrayInt::Aggregate(aa);//general case
+ else
+ _node_reduction=pflNodes->deepCpy();//case where no cells in read mesh.
+ _node_reduction->sort(true);
+ _node_reduction=_node_reduction->buildUnique();
+ if(_node_reduction->getNumberOfTuples()==pflNodes->getNumberOfTuples())
+ return ;//This is the classical case where the input node profile corresponds perfectly to a subset of cells in _parts
+ if(_node_reduction->getNumberOfTuples()>pflNodes->getNumberOfTuples())
+ throw INTERP_KERNEL::Exception("MEDUMeshMultiLev::selectPartOfNodes : internal error in MEDCoupling during cell select from a list of nodes !");
+ // Here the cells available in _parts is not enough to cover all the nodes in pflNodes. So adding vertices cells in _parts...
+ MEDCouplingAutoRefCountObjectPtr<DataArrayInt> pflNodes2(pflNodes->deepCpy());
+ pflNodes2->sort(true);
+ MEDCouplingAutoRefCountObjectPtr<DataArrayInt> diff(pflNodes2->buildSubstractionOptimized(_node_reduction));
+ appendVertices(diff,pflNodes2);
}
MEDMeshMultiLev *MEDUMeshMultiLev::prepare() const
}
/*!
+ * To be called only once ! Because due to some optimizations (sometimes aggressive) the internal state can be changed...
* If returned value is false output pointer \a coords is not the internal pointer. If returned value is true output pointer \a coords is directly the internal pointer.
* If true is returned, the \a coords output parameter should be used with care (non const method call) to avoid to change the internal state of MEDFileUMesh instance.
*/
{
*dPtr++=connIPtr[1]-connIPtr[0];
dPtr=std::copy(connPtr+connIPtr[0],connPtr+connIPtr[1],dPtr);
- *cPtr++=k; k+=connIPtr[1]-connIPtr[0];
+ *cPtr++=k; k+=connIPtr[1]-connIPtr[0]+1;
}
}
else
{ faceLocations=0; faces=0; }
else
{ faceLocations=e.retn(); faces=f.retn(); }
- return tmp==((DataArrayDouble *)a);
+ return _mesh->isObjectInTheProgeny(coords);
}
void MEDUMeshMultiLev::reorderNodesIfNecessary(MEDCouplingAutoRefCountObjectPtr<DataArrayDouble>& coords, DataArrayInt *nodalConnVTK, DataArrayInt *polyhedNodalConnVTK) const
//=
-MEDStructuredMeshMultiLev::MEDStructuredMeshMultiLev(const MEDFileStructuredMesh *m):MEDMeshMultiLev(m),_is_internal(true)
+MEDStructuredMeshMultiLev::MEDStructuredMeshMultiLev(const MEDFileStructuredMesh *m, const std::vector<int>& lev):MEDMeshMultiLev(m),_is_internal(true)
{
+ initStdFieldOfIntegers(m);
}
-MEDStructuredMeshMultiLev::MEDStructuredMeshMultiLev(const MEDFileStructuredMesh *m, const std::vector<int>& lev):MEDMeshMultiLev(m),_is_internal(true)
+MEDStructuredMeshMultiLev::MEDStructuredMeshMultiLev(const MEDFileStructuredMesh *m, int nbOfNodes, const std::vector<INTERP_KERNEL::NormalizedCellType>& gts, const std::vector<const DataArrayInt *>& pfls, const std::vector<int>& nbEntities):MEDMeshMultiLev(m,nbOfNodes,gts,pfls,nbEntities),_is_internal(true)
+{
+ initStdFieldOfIntegers(m);
+}
+
+MEDStructuredMeshMultiLev::MEDStructuredMeshMultiLev(const MEDStructuredMeshMultiLev& other):MEDMeshMultiLev(other),_is_internal(true),_face_fam_ids(other._face_fam_ids),_face_num_ids(other._face_num_ids)
+{
+}
+
+void MEDStructuredMeshMultiLev::initStdFieldOfIntegers(const MEDFileStructuredMesh *m)
{
// ids fields management
- _cell_fam_ids_nocpy=true; _cell_num_ids_nocpy=true;
const DataArrayInt *tmp(0);
tmp=m->getFamilyFieldAtLevel(0);
if(tmp)
_cell_num_ids=const_cast<DataArrayInt *>(tmp);
}
//
- _node_fam_ids_nocpy=true; _node_num_ids_nocpy=true;
tmp=0;
tmp=m->getFamilyFieldAtLevel(1);
if(tmp)
tmp->incrRef();
_node_num_ids=const_cast<DataArrayInt *>(tmp);
}
-}
-
-MEDStructuredMeshMultiLev::MEDStructuredMeshMultiLev(const MEDFileStructuredMesh *m, int nbOfNodes, const std::vector<INTERP_KERNEL::NormalizedCellType>& gts, const std::vector<const DataArrayInt *>& pfls, const std::vector<int>& nbEntities):MEDMeshMultiLev(m,nbOfNodes,gts,pfls,nbEntities),_is_internal(true)
-{
- // ids fields management
- _cell_fam_ids_nocpy=true; _cell_num_ids_nocpy=true;
- const DataArrayInt *tmp(0);
- tmp=m->getFamilyFieldAtLevel(0);
- if(tmp)
- {
- tmp->incrRef();
- _cell_fam_ids=const_cast<DataArrayInt *>(tmp);
- }
- tmp=m->getNumberFieldAtLevel(0);
- if(tmp)
- {
- tmp->incrRef();
- _cell_num_ids=const_cast<DataArrayInt *>(tmp);
- }
- //
- _node_fam_ids_nocpy=true; _node_num_ids_nocpy=true;
- tmp=0;
- tmp=m->getFamilyFieldAtLevel(1);
+ // faces (if any)
+ tmp=m->getFamilyFieldAtLevel(-1);
if(tmp)
{
tmp->incrRef();
- _node_fam_ids=const_cast<DataArrayInt *>(tmp);
+ _face_fam_ids=const_cast<DataArrayInt *>(tmp);
}
- tmp=m->getNumberFieldAtLevel(1);
+ tmp=m->getNumberFieldAtLevel(-1);
if(tmp)
{
tmp->incrRef();
- _node_num_ids=const_cast<DataArrayInt *>(tmp);
+ _face_num_ids=const_cast<DataArrayInt *>(tmp);
}
}
-MEDStructuredMeshMultiLev::MEDStructuredMeshMultiLev(const MEDStructuredMeshMultiLev& other):MEDMeshMultiLev(other),_is_internal(true)
+void MEDStructuredMeshMultiLev::moveFaceToCell() const
{
+ const_cast<MEDStructuredMeshMultiLev *>(this)->_cell_fam_ids=_face_fam_ids; const_cast<MEDStructuredMeshMultiLev *>(this)->_face_fam_ids=0;
+ const_cast<MEDStructuredMeshMultiLev *>(this)->_cell_num_ids=_face_num_ids; const_cast<MEDStructuredMeshMultiLev *>(this)->_face_num_ids=0;
}
bool MEDStructuredMeshMultiLev::prepareForImplicitUnstructuredMeshCase(MEDMeshMultiLev *&ret) const
{
ret=0;
+ if(_geo_types.empty())
+ return false;
+ if(_geo_types.size()!=1)
+ throw INTERP_KERNEL::Exception("MEDStructuredMeshMultiLev::prepareForImplicitUnstructuredMeshCase only one geo types supported at most supported for the moment !");
+ INTERP_KERNEL::NormalizedCellType gt(MEDCouplingStructuredMesh::GetGeoTypeGivenMeshDimension(_mesh->getMeshDimension()));
+ if(_geo_types[0]==gt)
+ return false;
MEDCoupling1GTUMesh *facesIfPresent((static_cast<const MEDFileStructuredMesh *>(_mesh))->getImplicitFaceMesh());
if(!facesIfPresent)
return false;
if(!_pfls.empty())
pfl=_pfls[0];
MEDCouplingAutoRefCountObjectPtr<MEDCoupling1GTUMesh> facesIfPresent2(facesIfPresent); facesIfPresent->incrRef();
+ moveFaceToCell();
MEDCouplingAutoRefCountObjectPtr<MEDUMeshMultiLev> ret2(new MEDUMeshMultiLev(*this,facesIfPresent2));
if(pfl)
- throw INTERP_KERNEL::Exception("MEDStructuredMeshMultiLev::prepareForImplicitUnstructuredMeshCase : case is not treated yet for profile on implicit unstructured mesh.");
+ ret2->setCellReduction(pfl);
if(nr)
throw INTERP_KERNEL::Exception("MEDStructuredMeshMultiLev::prepareForImplicitUnstructuredMeshCase : case is not treated yet for node reduction on implicit unstructured mesh.");
ret=ret2.retn();
void MEDStructuredMeshMultiLev::dealWithImplicitUnstructuredMesh(const MEDFileMesh *m)
{
- _cell_fam_ids_nocpy=true; _cell_num_ids_nocpy=true;
const DataArrayInt *tmp(0);
tmp=m->getFamilyFieldAtLevel(-1);
if(tmp)
if(famIds)
{
MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmp(famIds->selectByTupleIdSafe(pfl->begin(),pfl->end()));
- ret2->setFamilyIdsOnCells(tmp,false);
+ ret2->setFamilyIdsOnCells(tmp);
}
if(numIds)
{
MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmp(numIds->selectByTupleIdSafe(pfl->begin(),pfl->end()));
- ret2->setNumberIdsOnCells(tmp,false);
+ ret2->setNumberIdsOnCells(tmp);
}
return ret2.retn();
-
+
}
else
{
if(famIds)
{
MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmp(famIds->selectByTupleIdSafe(pfl->begin(),pfl->end()));
- ret2->setFamilyIdsOnCells(tmp,false);
+ ret2->setFamilyIdsOnCells(tmp);
}
if(numIds)
{
MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmp(numIds->selectByTupleIdSafe(pfl->begin(),pfl->end()));
- ret2->setNumberIdsOnCells(tmp,false);
+ ret2->setNumberIdsOnCells(tmp);
}
return ret2.retn();
}
if(_pfl->getName().empty())
{
if(nbOfEntity!=(_start_end.second-_start_end.first)/nip)
- throw INTERP_KERNEL::Exception("MEDFileField1TSStructItem2::checkInRange : Mismatch between number of entities and size of node field !");
+ throw INTERP_KERNEL::Exception("MEDFileField1TSStructItem2::checkInRange : Mismatch between number of entities and size of field !");
return ;
}
else
return true;
}
-bool MEDFileField1TSStructItem2::operator==(const MEDFileField1TSStructItem2& other) const throw(INTERP_KERNEL::Exception)
+bool MEDFileField1TSStructItem2::operator==(const MEDFileField1TSStructItem2& other) const
{
//_nb_of_entity is not taken into account here. It is not a bug, because no mesh consideration needed here to perform fast compare.
//idem for _loc. It is not an effective attribute for support comparison.
return ret;
}
-std::vector<const BigMemoryObject *> MEDFileField1TSStructItem2::getDirectChildren() const
+std::vector<const BigMemoryObject *> MEDFileField1TSStructItem2::getDirectChildrenWithNull() const
{
std::vector<const BigMemoryObject *> ret;
- const DataArrayInt *pfl(_pfl);
- if(pfl)
- ret.push_back(pfl);
+ ret.push_back((const DataArrayInt *)_pfl);
return ret;
}
void MEDFileField1TSStructItem::checkWithMeshStruct(const MEDFileMeshStruct *mst, const MEDFileFieldGlobsReal *globs)
{
switch(_type)
- {
+ {
case ON_NODES:
{
int nbOfEnt=mst->getNumberOfNodes();
}
default:
throw INTERP_KERNEL::Exception("MEDFileField1TSStructItem::checkWithMeshStruct : not managed field type !");
- }
+ }
}
-bool MEDFileField1TSStructItem::operator==(const MEDFileField1TSStructItem& other) const throw(INTERP_KERNEL::Exception)
+bool MEDFileField1TSStructItem::operator==(const MEDFileField1TSStructItem& other) const
{
if(_type!=other._type)
return false;
return false;
}
-const MEDFileField1TSStructItem2& MEDFileField1TSStructItem::operator[](std::size_t i) const throw(INTERP_KERNEL::Exception)
+const MEDFileField1TSStructItem2& MEDFileField1TSStructItem::operator[](std::size_t i) const
{
if(i>=_items.size())
throw INTERP_KERNEL::Exception("MEDFileField1TSStructItem::operator[] : input is not in valid range !");
return ret;
}
-std::vector<const BigMemoryObject *> MEDFileField1TSStructItem::getDirectChildren() const
+std::vector<const BigMemoryObject *> MEDFileField1TSStructItem::getDirectChildrenWithNull() const
{
std::vector<const BigMemoryObject *> ret;
for(std::vector< MEDFileField1TSStructItem2 >::const_iterator it=_items.begin();it!=_items.end();it++)
MEDFileField1TSStructItem MEDFileField1TSStructItem::BuildItemFrom(const MEDFileAnyTypeField1TS *ref, const MEDFileMeshStruct *meshSt)
{
- TypeOfField atype;
std::vector< MEDFileField1TSStructItem2 > anItems;
//
std::vector< std::vector<std::string> > pfls,locs;
std::size_t nbOfGeoTypes(geoTypes.size());
if(nbOfGeoTypes==0)
throw INTERP_KERNEL::Exception("MEDFileField1TSStruct : not null by empty ref !");
- bool isFirst=true;
+ if(typesF[0].empty())
+ throw INTERP_KERNEL::Exception("MEDFileField1TSStruct : internal error #1 bis !");
+ TypeOfField atype(typesF[0][0]);
for(std::size_t i=0;i<nbOfGeoTypes;i++)
{
std::size_t sz=typesF[i].size();
if(strtEnds[i].size()<1 || sz<1 || pfls[i].size()<1)
throw INTERP_KERNEL::Exception("MEDFileField1TSStruct : internal error #1 !");
//
- if(isFirst)
- atype=typesF[i][0];
- isFirst=false;
- //
for(std::size_t j=0;j<sz;j++)
{
if(atype==typesF[i][j])
}
}
MEDFileField1TSStructItem ret(atype,anItems);
- ret.checkWithMeshStruct(meshSt,ref);
+ try
+ {
+ ret.checkWithMeshStruct(meshSt,ref);
+ }
+ catch(INTERP_KERNEL::Exception& e)
+ {
+ std::ostringstream oss; oss << e.what() << " (" << MEDCouplingFieldDiscretization::GetTypeOfFieldRepr(ret.getType()) << ")";
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
+ }
return ret;
}
return ret;
}
-std::vector<const BigMemoryObject *> MEDFileField1TSStruct::getDirectChildren() const
+std::vector<const BigMemoryObject *> MEDFileField1TSStruct::getDirectChildrenWithNull() const
{
std::vector<const BigMemoryObject *> ret;
for(std::vector<MEDFileField1TSStructItem>::const_iterator it=_already_checked.begin();it!=_already_checked.end();it++)
for(int i=0;i<nbPts;i++)
{
MEDCouplingAutoRefCountObjectPtr<MEDFileAnyTypeField1TS> elt=ref->getTimeStepAtPos(i);
- _f1ts_cmps[i]=MEDFileField1TSStruct::New(elt,_mesh_comp);
- _f1ts_cmps[i]->checkWithMeshStruct(_mesh_comp,elt);
+ try
+ {
+ _f1ts_cmps[i]=MEDFileField1TSStruct::New(elt,_mesh_comp);
+ _f1ts_cmps[i]->checkWithMeshStruct(_mesh_comp,elt);
+ }
+ catch(INTERP_KERNEL::Exception& e)
+ {
+ std::ostringstream oss; oss << "Problem in field with name \"" << ref->getName() << "\"" << std::endl;
+ oss << "More Details : " << e.what();
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
+ }
}
}
return ret;
}
-std::vector<const BigMemoryObject *> MEDFileFastCellSupportComparator::getDirectChildren() const
+std::vector<const BigMemoryObject *> MEDFileFastCellSupportComparator::getDirectChildrenWithNull() const
{
std::vector<const BigMemoryObject *> ret;
const MEDFileMeshStruct *mst(_mesh_comp);
if(mst)
ret.push_back(mst);
for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileField1TSStruct> >::const_iterator it=_f1ts_cmps.begin();it!=_f1ts_cmps.end();it++)
- {
- const MEDFileField1TSStruct *cur(*it);
- if(cur)
- ret.push_back(cur);
- }
+ ret.push_back((const MEDFileField1TSStruct *)*it);
return ret;
}