-// Copyright (C) 2007-2014 CEA/DEN, EDF R&D
+// Copyright (C) 2007-2016 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 "MEDFileFieldOverView.hxx"
#include "MEDFileField.hxx"
#include "MEDLoader.hxx"
+#include "MEDFileSafeCaller.txx"
#include "MEDLoaderBase.hxx"
#include "MEDCouplingUMesh.hxx"
+#include "MEDCouplingMappedExtrudedMesh.hxx"
#include "InterpKernelAutoPtr.hxx"
extern med_geometry_type typmai3[34];
-using namespace ParaMEDMEM;
+using namespace MEDCoupling;
const char MEDFileMesh::DFT_FAM_NAME[]="FAMILLE_ZERO";
-MEDFileMesh::MEDFileMesh():_order(-1),_iteration(-1),_time(0.),_univ_wr_status(true)
+const char MEDFileUMesh::SPE_FAM_STR_EXTRUDED_MESH[]="HIDDEN_FAM_EXT_MESH@";
+
+MEDFileMesh::MEDFileMesh():_order(-1),_iteration(-1),_time(0.),_univ_wr_status(true),_axis_type(AX_CART)
{
}
return ret;
}
-std::vector<const BigMemoryObject *> MEDFileMesh::getDirectChildren() const
+std::vector<const BigMemoryObject *> MEDFileMesh::getDirectChildrenWithNull() const
{
- return std::vector<const BigMemoryObject *>();
+ std::vector<const BigMemoryObject *> ret(1);
+ ret[0]=(const MEDFileEquivalences *)_equiv;
+ return ret;
}
/*!
*/
MEDFileMesh *MEDFileMesh::New(const std::string& fileName, MEDFileMeshReadSelector *mrs)
{
- std::vector<std::string> ms=MEDLoader::GetMeshNames(fileName);
+ std::vector<std::string> ms=MEDCoupling::GetMeshNames(fileName);
if(ms.empty())
{
std::ostringstream oss; oss << "MEDFileMesh::New : no meshes in file \"" << fileName << "\" !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
MEDFileUtilities::CheckFileForRead(fileName);
- ParaMEDMEM::MEDCouplingMeshType meshType;
+ MEDCoupling::MEDCouplingMeshType meshType;
MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
int dt,it;
std::string dummy2;
- MEDFileMeshL2::GetMeshIdFromName(fid,ms.front(),meshType,dt,it,dummy2);
+ MEDCoupling::MEDCouplingAxisType dummy3;
+ MEDFileMeshL2::GetMeshIdFromName(fid,ms.front(),meshType,dummy3,dt,it,dummy2);
+ MCAuto<MEDFileMesh> ret;
switch(meshType)
- {
+ {
case UNSTRUCTURED:
{
- MEDCouplingAutoRefCountObjectPtr<MEDFileUMesh> ret=MEDFileUMesh::New();
- ret->loadUMeshFromFile(fid,ms.front(),dt,it,mrs);
- return (MEDFileUMesh *)ret.retn();
+ ret=MEDFileUMesh::New();
+ break;
}
case CARTESIAN:
{
- MEDCouplingAutoRefCountObjectPtr<MEDFileCMesh> ret=MEDFileCMesh::New();
- ret->loadCMeshFromFile(fid,ms.front(),dt,it,mrs);
- return (MEDFileCMesh *)ret.retn();
+ ret=MEDFileCMesh::New();
+ break;
}
case CURVE_LINEAR:
{
- MEDCouplingAutoRefCountObjectPtr<MEDFileCurveLinearMesh> ret=MEDFileCurveLinearMesh::New();
- ret->loadCLMeshFromFile(fid,ms.front(),dt,it,mrs);
- return (MEDFileCurveLinearMesh *)ret.retn();
+ ret=MEDFileCurveLinearMesh::New();
+ break;
}
default:
{
std::ostringstream oss; oss << "MEDFileMesh::New : MED file exists and has mesh '" << ms.front() << "' exists but unsupported type yet !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
- }
+ }
+ ret->loadLLWithAdditionalItems(fid,ms.front(),dt,it,mrs);
+ return ret.retn();
}
/*!
* \param [in] mName - the name of the mesh to read.
* \param [in] dt - the number of a time step.
* \param [in] it - the number of an iteration.
+ * \param [in] joints - the sub-domain joints to use instead of those that can be read
+ * from the MED file. Usually this joints are those just read by another iteration
+ * of mName mesh, when this method is called by MEDFileMeshMultiTS::New()
* \return MEDFileMesh * - a new instance of MEDFileMesh. The caller is to delete this
* mesh using decrRef() as it is no more needed.
* \throw If the file is not readable.
* \throw If there is no mesh with given attributes in the file.
* \throw If the mesh in the file is of a not supported type.
*/
-MEDFileMesh *MEDFileMesh::New(const std::string& fileName, const std::string& mName, int dt, int it, MEDFileMeshReadSelector *mrs)
+MEDFileMesh *MEDFileMesh::New(const std::string& fileName, const std::string& mName, int dt, int it, MEDFileMeshReadSelector *mrs, MEDFileJoints* joints)
{
MEDFileUtilities::CheckFileForRead(fileName);
- ParaMEDMEM::MEDCouplingMeshType meshType;
+ MEDCoupling::MEDCouplingMeshType meshType;
MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
int dummy0,dummy1;
std::string dummy2;
- MEDFileMeshL2::GetMeshIdFromName(fid,mName,meshType,dummy0,dummy1,dummy2);
+ MEDCoupling::MEDCouplingAxisType dummy3;
+ MEDFileMeshL2::GetMeshIdFromName(fid,mName,meshType,dummy3,dummy0,dummy1,dummy2);
+ MCAuto<MEDFileMesh> ret;
switch(meshType)
- {
+ {
case UNSTRUCTURED:
{
- MEDCouplingAutoRefCountObjectPtr<MEDFileUMesh> ret=MEDFileUMesh::New();
- ret->loadUMeshFromFile(fid,mName,dt,it,mrs);
- return (MEDFileUMesh *)ret.retn();
+ ret=MEDFileUMesh::New();
+ break;
}
case CARTESIAN:
{
- MEDCouplingAutoRefCountObjectPtr<MEDFileCMesh> ret=MEDFileCMesh::New();
- ret->loadCMeshFromFile(fid,mName,dt,it,mrs);
- return (MEDFileCMesh *)ret.retn();
+ ret=MEDFileCMesh::New();
+ break;
}
case CURVE_LINEAR:
{
- MEDCouplingAutoRefCountObjectPtr<MEDFileCurveLinearMesh> ret=MEDFileCurveLinearMesh::New();
- ret->loadCLMeshFromFile(fid,mName,dt,it,mrs);
- return (MEDFileCurveLinearMesh *)ret.retn();
+ ret=MEDFileCurveLinearMesh::New();
+ break;
}
default:
{
std::ostringstream oss; oss << "MEDFileMesh::New : MED file exists and has mesh '" << mName << "' exists but unsupported type yet !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
- }
+ }
+ ret->loadLLWithAdditionalItems(fid,mName,dt,it,mrs);
+ return ret.retn();
}
/*!
if(_name.empty())
throw INTERP_KERNEL::Exception("MEDFileMesh : name is empty. MED file ask for a NON EMPTY name !");
writeLL(fid);
+ writeJoints(fid);
+ const MEDFileEquivalences *eqs(_equiv);
+ if(eqs)
+ eqs->write(fid);
}
/*!
return false;
if(!areFamsEqual(other,what))
return false;
+ if(!areEquivalencesEqual(other,what))
+ return false;
return true;
}
*/
void MEDFileMesh::clearNonDiscrAttributes() const
{
-
+
}
bool MEDFileMesh::changeNames(const std::vector< std::pair<std::string,std::string> >& modifTab)
return ret;
}
+/*!
+ * Returns names of all families of \a this mesh but like they would be in file.
+ * This method is here only for MED file families gurus. If you are a kind user forget this method :-)
+ * This method is only useful for aggressive users that want to have in their file a same family lying both on cells and on nodes. This is not a good idea for lisibility !
+ * For your information internaly in memory such families are renamed to have a nicer API.
+ */
+std::vector<std::string> MEDFileMesh::getFamiliesNamesWithFilePointOfView() const
+{
+ std::vector<std::string> ret(getFamiliesNames());
+ MEDFileMeshL2::RenameFamiliesFromMemToFile(ret);
+ return ret;
+}
+
+/*!
+ * Returns names of groups that partly or fully appear on the level \a meshDimRelToMaxExt.
+ * \param [in] meshDimRelToMaxExt - a relative dimension of interest.
+ * \return std::vector<std::string> - a sequence of group names at \a meshDimRelToMaxExt
+ * level.
+ */
+std::vector<std::string> MEDFileMesh::getGroupsOnSpecifiedLev(int meshDimRelToMaxExt) const
+{
+ std::vector<std::string> ret;
+ std::vector<std::string> allGrps(getGroupsNames());
+ for(std::vector<std::string>::const_iterator it=allGrps.begin();it!=allGrps.end();it++)
+ {
+ std::vector<int> levs(getGrpNonEmptyLevelsExt((*it)));
+ if(std::find(levs.begin(),levs.end(),meshDimRelToMaxExt)!=levs.end())
+ ret.push_back(*it);
+ }
+ return ret;
+}
+
+/*!
+ * Returns all relative mesh levels (including nodes) where a given group is defined.
+ * \param [in] grp - the name of the group of interest.
+ * \return std::vector<int> - a sequence of the relative dimensions.
+ */
+std::vector<int> MEDFileMesh::getGrpNonEmptyLevelsExt(const std::string& grp) const
+{
+ std::vector<std::string> fams(getFamiliesOnGroup(grp));
+ return getFamsNonEmptyLevelsExt(fams);
+}
+
+/*!
+ * Returns all relative mesh levels (**excluding nodes**) where given groups are defined.
+ * To include nodes, call getGrpsNonEmptyLevelsExt() method.
+ * \param [in] grps - a sequence of names of the groups of interest.
+ * \return std::vector<int> - a sequence of the relative dimensions.
+ */
+std::vector<int> MEDFileMesh::getGrpsNonEmptyLevels(const std::vector<std::string>& grps) const
+{
+ std::vector<std::string> fams(getFamiliesOnGroups(grps));
+ return getFamsNonEmptyLevels(fams);
+}
+
+/*!
+ * Returns all relative mesh levels (including nodes) where given groups are defined.
+ * \param [in] grps - a sequence of names of the groups of interest.
+ * \return std::vector<int> - a sequence of the relative dimensions.
+ */
+std::vector<int> MEDFileMesh::getGrpsNonEmptyLevelsExt(const std::vector<std::string>& grps) const
+{
+ std::vector<std::string> fams(getFamiliesOnGroups(grps));
+ return getFamsNonEmptyLevelsExt(fams);
+}
+
+/*!
+ * Returns all relative mesh levels (**excluding nodes**) where a given group is defined.
+ * To include nodes, call getGrpNonEmptyLevelsExt() method.
+ * \param [in] grp - the name of the group of interest.
+ * \return std::vector<int> - a sequence of the relative dimensions.
+ */
+std::vector<int> MEDFileMesh::getGrpNonEmptyLevels(const std::string& grp) const
+{
+ std::vector<std::string> fams(getFamiliesOnGroup(grp));
+ return getFamsNonEmptyLevels(fams);
+}
+
+/*!
+ * Returns all relative mesh levels (**excluding nodes**) where a given family is defined.
+ * To include nodes, call getFamNonEmptyLevelsExt() method.
+ * \param [in] fam - the name of the family of interest.
+ * \return std::vector<int> - a sequence of the relative dimensions.
+ */
+std::vector<int> MEDFileMesh::getFamNonEmptyLevels(const std::string& fam) const
+{
+ std::vector<std::string> fams(1,std::string(fam));
+ return getFamsNonEmptyLevels(fams);
+}
+
+/*!
+ * Returns all relative mesh levels (including nodes) where a given family is defined.
+ * \param [in] fam - the name of the family of interest.
+ * \return std::vector<int> - a sequence of the relative dimensions.
+ */
+std::vector<int> MEDFileMesh::getFamNonEmptyLevelsExt(const std::string& fam) const
+{
+ std::vector<std::string> fams(1,std::string(fam));
+ return getFamsNonEmptyLevelsExt(fams);
+}
+
+std::string MEDFileMesh::GetMagicFamilyStr()
+{
+ return std::string(MEDFileMeshL2::ZE_SEP_FOR_FAMILY_KILLERS);
+}
+
/*!
* Changes a name of every family, included in one group only, to be same as the group name.
* \throw If there are families with equal names in \a this mesh.
*/
std::vector<std::string> MEDFileMesh::removeOrphanFamilies()
{
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> allFamIdsInUse=computeAllFamilyIdsInUse();
+ MCAuto<DataArrayInt> allFamIdsInUse=computeAllFamilyIdsInUse();
std::vector<std::string> ret;
if(!((DataArrayInt*)allFamIdsInUse))
{
return ret;
}
+/*!
+ * This method operates only on maps in \a this. The arrays are not considered here. So this method will remove a family (except "FAMILLE_ZERO" family) if no group lies on it whatever
+ * this family is orphan or not.
+ *
+ * \warning this method is different from removeOrphanFamilies that scans family field array to find orphan families.
+ */
+void MEDFileMesh::removeFamiliesReferedByNoGroups()
+{
+ std::map<std::string,int> fams;
+ std::set<std::string> sfams;
+ for(std::map<std::string,int>::const_iterator it=_families.begin();it!=_families.end();it++)
+ sfams.insert((*it).first);
+ for(std::map<std::string, std::vector<std::string> >::const_iterator it0=_groups.begin();it0!=_groups.end();it0++)
+ for(std::vector<std::string>::const_iterator it1=(*it0).second.begin();it1!=(*it0).second.end();it1++)
+ sfams.erase(*it1);
+ for(std::set<std::string>::const_iterator it=sfams.begin();it!=sfams.end();it++)
+ if(*it!=DFT_FAM_NAME)
+ _families.erase(*it);
+}
+
+/*!
+ * This method has no impact on groups. This method only works on families. This method firstly removes families not refered by any groups in \a this, then all unused entities
+ * are put as belonging to family 0 ("FAMILLE_ZERO"). Finally, all orphanFamilies are killed.
+ * This method raises an exception if "FAMILLE_ZERO" is already belonging to a group.
+ *
+ * \sa MEDFileMesh::removeOrphanFamilies
+ */
+void MEDFileMesh::rearrangeFamilies()
+{
+ checkOrphanFamilyZero();
+ removeFamiliesReferedByNoGroups();
+ //
+ std::vector<int> levels(getNonEmptyLevelsExt());
+ std::set<int> idsRefed;
+ for(std::map<std::string,int>::const_iterator it=_families.begin();it!=_families.end();it++)
+ idsRefed.insert((*it).second);
+ for(std::vector<int>::const_iterator it=levels.begin();it!=levels.end();it++)
+ {
+ const DataArrayInt *fams(0);
+ try
+ {
+ fams=getFamilyFieldAtLevel(*it);
+ }
+ catch(INTERP_KERNEL::Exception& e) { }
+ if(!fams)
+ continue;
+ std::vector<bool> v(fams->getNumberOfTuples(),false);
+ for(std::set<int>::const_iterator pt=idsRefed.begin();pt!=idsRefed.end();pt++)
+ fams->switchOnTupleEqualTo(*pt,v);
+ MCAuto<DataArrayInt> unfetchedIds(DataArrayInt::BuildListOfSwitchedOff(v));
+ if(!unfetchedIds->empty())
+ {
+ MCAuto<DataArrayInt> newFams(fams->deepCopy());
+ newFams->setPartOfValuesSimple3(0,unfetchedIds->begin(),unfetchedIds->end(),0,1,1);
+ setFamilyFieldArr(*it,newFams);
+ }
+ }
+ removeOrphanFamilies();
+}
+
+/*!
+ * This method only checks that "FAMILLE_ZERO" is orphan (not belonging to a group).
+ */
+void MEDFileMesh::checkOrphanFamilyZero() const
+{
+ for(std::map<std::string, std::vector<std::string> >::const_iterator it=_groups.begin();it!=_groups.end();it++)
+ {
+ if(std::find((*it).second.begin(),(*it).second.end(),DFT_FAM_NAME)!=(*it).second.end())
+ {
+ std::ostringstream oss; oss << "MEDFileMesh::rearrangeFamilies : Groups \"" << (*it).first << "\" is lying on family \"" << DFT_FAM_NAME << "\" !";
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
+ }
+ }
+}
+
/*!
* Renames a group in \a this mesh.
* \param [in] oldName - a current name of the group to rename.
{
oss << " Group \"" << (*it).first << "\" on following families :\n";
for(std::vector<std::string>::const_iterator it2=(*it).second.begin();it2!=(*it).second.end();it2++)
- oss << " \"" << *it2 << "\n";
+ oss << " \"" << *it2 << "\n";
}
oss << "Second group description :\n";
for(std::map<std::string, std::vector<std::string> >::const_iterator it=other->_groups.begin();it!=other->_groups.end();it++)
std::map<std::string,int>::const_iterator it=_families.find(fname);
if(it==_families.end())
{
- for(std::map<std::string,int>::const_iterator it2=_families.begin();it2!=_families.end();it2++)
- if((*it2).second==famId)
- {
- std::ostringstream oss;
- oss << "MEDFileMesh::addFamily : Family \"" << (*it2).first << "\" already exists with specified id : " << famId << " !";
- throw INTERP_KERNEL::Exception(oss.str().c_str());
- }
- _families[fname]=famId;
+ for(std::map<std::string,int>::const_iterator it2=_families.begin();it2!=_families.end();it2++)
+ if((*it2).second==famId)
+ {
+ std::ostringstream oss;
+ oss << "MEDFileMesh::addFamily : Family \"" << (*it2).first << "\" already exists with specified id : " << famId << " !";
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
+ }
+ _families[fname]=famId;
}
else
{
const DataArrayInt *fieldFamIds=getFamilyFieldAtLevel(meshDimRelToMaxExt);
if(fieldFamIds==0)
throw INTERP_KERNEL::Exception("MEDFileMesh::createGroupOnAll : Family field arr ids is not defined for this level !");
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> famIds=fieldFamIds->getDifferentValues();
+ MCAuto<DataArrayInt> famIds=fieldFamIds->getDifferentValues();
std::vector<std::string> familiesOnWholeGroup;
for(const int *it=famIds->begin();it!=famIds->end();it++)
{
const DataArrayInt *fieldFamIds=getFamilyFieldAtLevel(*it);
if(fieldFamIds)
{
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> famIds3=fieldFamIds->getDifferentValues();
+ MCAuto<DataArrayInt> famIds3=fieldFamIds->getDifferentValues();
std::vector<int> tmp;
std::set_intersection(famIds3->begin(),famIds3->end(),famIds2.begin(),famIds2.end(),std::back_insert_iterator< std::vector<int> >(tmp));
for(std::vector<int>::const_iterator it2=tmp.begin();it2!=tmp.end();it2++)
}
}
+/*!
+ * \param [in] ids ids and group name of the new group to add. The ids should be sorted and different each other (MED file norm).
+ * \parma [in,out] famArr family array on level of interest to be renumbered. The input pointer should be not \c NULL (no check of that will be performed)
+ */
+void MEDFileMesh::addGroupUnderground(bool isNodeGroup, const DataArrayInt *ids, DataArrayInt *famArr)
+{
+ if(!ids)
+ throw INTERP_KERNEL::Exception("MEDFileUMesh::addGroup : NULL pointer in input !");
+ std::string grpName(ids->getName());
+ if(grpName.empty())
+ throw INTERP_KERNEL::Exception("MEDFileUMesh::addGroup : empty group name ! MED file format do not accept empty group name !");
+ ids->checkStrictlyMonotonic(true);
+ famArr->incrRef(); MCAuto<DataArrayInt> famArrTmp(famArr);
+ std::vector<std::string> grpsNames=getGroupsNames();
+ if(std::find(grpsNames.begin(),grpsNames.end(),grpName)!=grpsNames.end())
+ {
+ std::ostringstream oss; oss << "MEDFileUMesh::addGroup : Group with name \"" << grpName << "\" already exists ! Destroy it before calling this method !";
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
+ }
+ std::list< MCAuto<DataArrayInt> > allFamIds(getAllNonNullFamilyIds());
+ allFamIds.erase(std::find(allFamIds.begin(),allFamIds.end(),famArrTmp));
+ MCAuto<DataArrayInt> famIds=famArr->selectByTupleIdSafe(ids->begin(),ids->end());
+ MCAuto<DataArrayInt> diffFamIds=famIds->getDifferentValues();
+ std::vector<int> familyIds;
+ std::vector< MCAuto<DataArrayInt> > idsPerfamiliyIds;
+ int maxVal=getTheMaxAbsFamilyId()+1;
+ std::map<std::string,int> families(_families);
+ std::map<std::string, std::vector<std::string> > groups(_groups);
+ std::vector<std::string> fams;
+ bool created(false);
+ for(const int *famId=diffFamIds->begin();famId!=diffFamIds->end();famId++)
+ {
+ MCAuto<DataArrayInt> ids2Tmp=famIds->findIdsEqual(*famId);
+ MCAuto<DataArrayInt> ids2=ids->selectByTupleId(ids2Tmp->begin(),ids2Tmp->end());
+ MCAuto<DataArrayInt> ids1=famArr->findIdsEqual(*famId);
+ MCAuto<DataArrayInt> ret0(ids1->buildSubstractionOptimized(ids2));
+ if(ret0->empty())
+ {
+ bool isFamPresent=false;
+ for(std::list< MCAuto<DataArrayInt> >::const_iterator itl=allFamIds.begin();itl!=allFamIds.end() && !isFamPresent;itl++)
+ isFamPresent=(*itl)->presenceOfValue(*famId);
+ if(!isFamPresent)
+ { familyIds.push_back(*famId); idsPerfamiliyIds.push_back(ret0); fams.push_back(FindOrCreateAndGiveFamilyWithId(families,*famId,created)); } // adding *famId in grp
+ else
+ {
+ familyIds.push_back(isNodeGroup?maxVal:-maxVal); idsPerfamiliyIds.push_back(ids2);
+ std::string locFamName=FindOrCreateAndGiveFamilyWithId(families,isNodeGroup?maxVal:-maxVal,created);
+ fams.push_back(locFamName);
+ if(existsFamily(*famId))
+ {
+ std::string locFamName2=getFamilyNameGivenId(*famId); std::vector<std::string> v(2); v[0]=locFamName2; v[1]=locFamName;
+ ChangeAllGroupsContainingFamily(groups,getFamilyNameGivenId(*famId),v);
+ }
+ maxVal++;
+ } // modifying all other groups on *famId to lie on maxVal and lie the grp on maxVal
+ }
+ else
+ {
+ familyIds.push_back(isNodeGroup?maxVal:-maxVal); idsPerfamiliyIds.push_back(ret0); // modifying all other groups on *famId to lie on maxVal and on maxVal+1
+ familyIds.push_back(isNodeGroup?maxVal+1:-maxVal-1); idsPerfamiliyIds.push_back(ids2);//grp lie only on maxVal+1
+ std::string n2(FindOrCreateAndGiveFamilyWithId(families,isNodeGroup?maxVal+1:-maxVal-1,created)); fams.push_back(n2);
+ if(existsFamily(*famId))
+ {
+ std::string n1(FindOrCreateAndGiveFamilyWithId(families,isNodeGroup?maxVal:-maxVal,created)); std::vector<std::string> v(2); v[0]=n1; v[1]=n2;
+ ChangeAllGroupsContainingFamily(groups,getFamilyNameGivenId(*famId),v);
+ }
+ maxVal+=2;
+ }
+ }
+ for(std::size_t i=0;i<familyIds.size();i++)
+ {
+ DataArrayInt *da=idsPerfamiliyIds[i];
+ famArr->setPartOfValuesSimple3(familyIds[i],da->begin(),da->end(),0,1,1);
+ }
+ _families=families;
+ _groups=groups;
+ _groups[grpName]=fams;
+}
+
void MEDFileMesh::changeAllGroupsContainingFamily(const std::string& familyNameToChange, const std::vector<std::string>& newFamiliesNames)
{
ChangeAllGroupsContainingFamily(_groups,familyNameToChange,newFamiliesNames);
*/
int MEDFileMesh::getFamilyId(const std::string& name) const
{
- std::string oname(name);
- std::map<std::string, int>::const_iterator it=_families.find(oname);
- std::vector<std::string> fams=getFamiliesNames();
+ std::map<std::string, int>::const_iterator it=_families.find(name);
if(it==_families.end())
{
+ std::vector<std::string> fams(getFamiliesNames());
std::ostringstream oss; oss << "No such familyname \"" << name << "\" !\nAvailable families are :";
std::copy(fams.begin(),fams.end(),std::ostream_iterator<std::string>(oss," "));
throw INTERP_KERNEL::Exception(oss.str().c_str());
*/
DataArrayInt *MEDFileMesh::getAllFamiliesIdsReferenced() const
{
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
+ MCAuto<DataArrayInt> ret=DataArrayInt::New();
std::set<int> v;
for(std::map<std::string,int>::const_iterator it=_families.begin();it!=_families.end();it++)
v.insert((*it).second);
DataArrayInt *MEDFileMesh::computeAllFamilyIdsInUse() const
{
std::vector<int> famLevs=getFamArrNonEmptyLevelsExt();
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret;
+ MCAuto<DataArrayInt> ret;
for(std::vector<int>::const_iterator it=famLevs.begin();it!=famLevs.end();it++)
{
const DataArrayInt *arr=getFamilyFieldAtLevel(*it);//arr not null due to spec of getFamArrNonEmptyLevelsExt
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> dv=arr->getDifferentValues();
+ MCAuto<DataArrayInt> dv=arr->getDifferentValues();
if((DataArrayInt *) ret)
ret=dv->buildUnion(ret);
else
const DataArrayInt *fam=getFamilyFieldAtLevel(*it);
if(fam)
{
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmp=fam->getDifferentValues();
+ MCAuto<DataArrayInt> tmp=fam->getDifferentValues();
std::set<int> r2;
std::set_intersection(tmp->begin(),tmp->end(),allFamIds.begin(),allFamIds.end(),std::inserter(r2,r2.end()));
if(!r2.empty())
}
if(famIdsToRenum.empty())
return true;
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> allIds=getAllFamiliesIdsReferenced();
+ MCAuto<DataArrayInt> allIds=getAllFamiliesIdsReferenced();
for(std::map<int,std::vector<int> >::const_iterator it2=famIdsToRenum.begin();it2!=famIdsToRenum.end();it2++)
{
DataArrayInt *fam=const_cast<DataArrayInt *>(getFamilyFieldAtLevel((*it2).first));
addFamilyOnGrp((*it4),newFam);
}
}
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ids=fam->getIdsEqualList(&(*it2).second[0],&(*it2).second[0]+(*it2).second.size());
+ MCAuto<DataArrayInt> ids=fam->findIdsEqualList(&(*it2).second[0],&(*it2).second[0]+(*it2).second.size());
for(const int *id=ids->begin();id!=ids->end();id++)
famIdsToChange[*id]=ren[famIdsToChange[*id]];
}
void MEDFileMesh::normalizeFamIdsTrio()
{
ensureDifferentFamIdsPerLevel();
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> allIds=getAllFamiliesIdsReferenced();
+ MCAuto<DataArrayInt> allIds=getAllFamiliesIdsReferenced();
std::vector<int> levs=getNonEmptyLevelsExt();
std::set<int> levsS(levs.begin(),levs.end());
std::set<std::string> famsFetched;
if(fam)
{
int refId=1;
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmp=fam->getDifferentValues();
+ MCAuto<DataArrayInt> tmp=fam->getDifferentValues();
std::map<int,int> ren;
for(const int *it=tmp->begin();it!=tmp->end();it++,refId++)
ren[*it]=refId;
if(fam)
{
int refId=-1;
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmp=fam->getDifferentValues();
+ MCAuto<DataArrayInt> tmp=fam->getDifferentValues();
std::map<int,int> ren;
for(const int *it=tmp->begin();it!=tmp->end();it++,refId--)
ren[*it]=refId;
DataArrayInt *fam=const_cast<DataArrayInt*>(getFamilyFieldAtLevel(*it2));
if(fam)
{
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmp=fam->getDifferentValues();
+ MCAuto<DataArrayInt> tmp=fam->getDifferentValues();
fam->fillWithZero();
for(const int *it3=tmp->begin();it3!=tmp->end();it3++)
if(allIds->presenceOfValue(*it3))
void MEDFileMesh::normalizeFamIdsMEDFile()
{
ensureDifferentFamIdsPerLevel();
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> allIds=getAllFamiliesIdsReferenced();
+ MCAuto<DataArrayInt> allIds=getAllFamiliesIdsReferenced();
std::vector<int> levs=getNonEmptyLevelsExt();
std::set<int> levsS(levs.begin(),levs.end());
std::set<std::string> famsFetched;
const DataArrayInt *fam=getFamilyFieldAtLevel(1);
if(fam)
{
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmp=fam->getDifferentValues();
+ MCAuto<DataArrayInt> tmp=fam->getDifferentValues();
std::map<int,int> ren;
for(const int *it=tmp->begin();it!=tmp->end();it++,refId++)
ren[*it]=refId;
const DataArrayInt *fam=getFamilyFieldAtLevel(*it2);
if(fam)
{
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmp=fam->getDifferentValues();
+ MCAuto<DataArrayInt> tmp=fam->getDifferentValues();
std::map<int,int> ren;
for(const int *it=tmp->begin();it!=tmp->end();it++,refId--)
ren[*it]=refId;
return oss.str();
}
+/*!
+ * This method is nearly like getFamilyFieldAtLevel method. Except that if the array does not exist at the specified level \a meshDimRelToMaxExt
+ * an empty one is created.
+ */
+DataArrayInt *MEDFileMesh::getOrCreateAndGetFamilyFieldAtLevel(int meshDimRelToMaxExt)
+{
+ DataArrayInt *ret(getFamilyFieldAtLevel(meshDimRelToMaxExt));
+ if(ret)
+ return ret;
+ MCAuto<DataArrayInt> arr(DataArrayInt::New());
+ arr->alloc(getSizeAtLevel(meshDimRelToMaxExt),1);
+ arr->fillWithZero();
+ setFamilyFieldArr(meshDimRelToMaxExt,arr);
+ return getFamilyFieldAtLevel(meshDimRelToMaxExt);
+}
+
/*!
* Returns ids of mesh entities contained in a given group of a given dimension.
* \param [in] meshDimRelToMaxExt - a relative dimension of the mesh entities whose ids
if(grpsName.find(std::string(""))!=grpsName.end())
throw INTERP_KERNEL::Exception("MEDFileUMesh::setGroupsAtLevel : groups name must be different empty string !");
int sz=getSizeAtLevel(meshDimRelToMaxExt);
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> fam;
+ MCAuto<DataArrayInt> fam;
std::vector< std::vector<int> > fidsOfGroups;
if(!renum)
{
}
else
{
- std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > grps2(grps.size());
+ std::vector< MCAuto<DataArrayInt> > grps2(grps.size());
for(unsigned int ii=0;ii<grps.size();ii++)
{
grps2[ii]=MEDFileUMeshSplitL1::Renumber(getRevNumberFieldAtLevel(meshDimRelToMaxExt),grps[ii]);
if(!_families.empty())
offset=getMaxAbsFamilyId()+1;
TranslateFamilyIds(meshDimRelToMaxExt==1?offset:-offset,fam,fidsOfGroups);
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ids=fam->getDifferentValues();
+ MCAuto<DataArrayInt> ids=fam->getDifferentValues();
appendFamilyEntries(ids,fidsOfGroups,grpsName2);
setFamilyFieldArr(meshDimRelToMaxExt,fam);
}
return ret;
}
+/*!
+ * \sa getAllDistributionOfTypes
+ */
std::vector<int> MEDFileMesh::getDistributionOfTypes(int meshDimRelToMax) const
{
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingMesh> mLev(getGenMeshAtLevel(meshDimRelToMax));
+ MCAuto<MEDCouplingMesh> mLev(getMeshAtLevel(meshDimRelToMax));
return mLev->getDistributionOfTypes();
}
+void MEDFileMesh::loadLLWithAdditionalItems(med_idt fid, const std::string& mName, int dt, int it, MEDFileMeshReadSelector *mrs)
+{
+ loadLL(fid,mName,dt,it,mrs);
+ loadJointsFromFile(fid);
+ loadEquivalences(fid);
+}
+
void MEDFileMesh::TranslateFamilyIds(int offset, DataArrayInt *famArr, std::vector< std::vector<int> >& famIdsPerGrp)
{
famArr->applyLin(offset>0?1:-1,offset,0);
*/
MEDFileUMesh *MEDFileUMesh::New(const std::string& fileName, MEDFileMeshReadSelector *mrs)
{
- std::vector<std::string> ms=MEDLoader::GetMeshNames(fileName);
+ std::vector<std::string> ms(MEDCoupling::GetMeshNames(fileName));
if(ms.empty())
{
std::ostringstream oss; oss << "MEDFileUMesh::New : no meshes in file \"" << fileName << "\" !";
MEDFileUtilities::CheckFileForRead(fileName);
MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
int dt,it;
- ParaMEDMEM::MEDCouplingMeshType meshType;
+ MEDCoupling::MEDCouplingMeshType meshType;
std::string dummy2;
- MEDFileMeshL2::GetMeshIdFromName(fid,ms.front(),meshType,dt,it,dummy2);
+ MEDCoupling::MEDCouplingAxisType dummy3;
+ MEDFileMeshL2::GetMeshIdFromName(fid,ms.front(),meshType,dummy3,dt,it,dummy2);
return new MEDFileUMesh(fid,ms.front(),dt,it,mrs);
}
+/*!
+ * \b WARNING this implementation is dependant from MEDCouplingMappedExtrudedMesh::buildUnstructured !
+ * \sa MEDCouplingMappedExtrudedMesh::buildUnstructured , MEDCouplingMappedExtrudedMesh::build3DUnstructuredMesh
+ */
+MEDFileUMesh *MEDFileUMesh::New(const MEDCouplingMappedExtrudedMesh *mem)
+{
+ if(!mem)
+ throw INTERP_KERNEL::Exception("MEDFileUMesh::New : null input vector !");
+ MCAuto<MEDFileUMesh> ret(MEDFileUMesh::New());
+ MCAuto<MEDCouplingUMesh> m3D(mem->buildUnstructured());
+ MCAuto<MEDCouplingUMesh> m2D(mem->getMesh2D()->deepCopy());
+ m2D->zipCoords();
+ m2D->setCoords(m3D->getCoords());
+ ret->setMeshAtLevel(0,m3D);
+ ret->setMeshAtLevel(-1,m2D);
+ ret->setFamilyId(GetSpeStr4ExtMesh(),mem->get2DCellIdForExtrusion());
+ return ret.retn();
+}
+
/*!
* Returns an empty instance of MEDFileUMesh.
* \return MEDFileUMesh * - a new instance of MEDFileUMesh. The caller is to delete this
return new MEDFileUMesh;
}
+/*!
+ * This method loads from file with name \a fileName the mesh called \a mName as New does. The difference is that
+ * here only a part of cells contained in the file will be loaded. The selection of cell is specified using the two consecutive parameters
+ * \a types and \a slicPerTyp. This method allows to load from a mesh (typically huge) in a MED file a part of cells of that mesh.
+ * The part of cells is specified using triplet (start,stop,step) for each geometric type. Only nodes lying on selected cells will be loaded to reduce
+ * at most the memory consumtion.
+ *
+ * \param [in] fileName - the name of the file.
+ * \param [in] mName - the name of the mesh to be read.
+ * \param [in] types - the list of the geo types of which some part will be taken. A geometric type in \a types must appear only once at most.
+ * \param [in] slicPerType - an array of size 3 times larger than \a types that specifies for each type in \a types (in the same order) resp the start, the stop and the step.
+ * \param [in] dt - the iteration, that is to say the first element of the pair that locates the asked time step.
+ * \param [in] it - the order, that is to say the second element of the pair that locates the asked time step.
+ * \param [in] mrs - the request for what to be loaded.
+ * \return MEDFileUMesh * - a new instance of MEDFileUMesh. The caller is to delete this mesh using decrRef() as it is no more needed.
+ */
+MEDFileUMesh *MEDFileUMesh::LoadPartOf(const std::string& fileName, const std::string& mName, const std::vector<INTERP_KERNEL::NormalizedCellType>& types, const std::vector<int>& slicPerTyp, int dt, int it, MEDFileMeshReadSelector *mrs)
+{
+ MEDFileUtilities::CheckFileForRead(fileName);
+ MEDFileUtilities::AutoFid fid(MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY));
+ return MEDFileUMesh::LoadPartOf(fid,mName,types,slicPerTyp,dt,it,mrs);
+}
+
+/*!
+ * Please refer to the other MEDFileUMesh::LoadPartOf method that has the same semantic and the same parameter (excepted the first).
+ * This method is \b NOT wrapped into python.
+ */
+MEDFileUMesh *MEDFileUMesh::LoadPartOf(med_idt fid, const std::string& mName, const std::vector<INTERP_KERNEL::NormalizedCellType>& types, const std::vector<int>& slicPerTyp, int dt, int it, MEDFileMeshReadSelector *mrs)
+{
+ MCAuto<MEDFileUMesh> ret(MEDFileUMesh::New());
+ ret->loadPartUMeshFromFile(fid,mName,types,slicPerTyp,dt,it,mrs);
+ return ret.retn();
+}
+
std::size_t MEDFileUMesh::getHeapMemorySizeWithoutChildren() const
{
std::size_t ret(MEDFileMesh::getHeapMemorySizeWithoutChildren());
- ret+=_ms.capacity()*(sizeof(MEDCouplingAutoRefCountObjectPtr<MEDFileUMeshSplitL1>));
+ ret+=_ms.capacity()*(sizeof(MCAuto<MEDFileUMeshSplitL1>));
return ret;
}
-std::vector<const BigMemoryObject *> MEDFileUMesh::getDirectChildren() const
+std::vector<const BigMemoryObject *> MEDFileUMesh::getDirectChildrenWithNull() const
{
- std::vector<const BigMemoryObject *> ret(MEDFileMesh::getDirectChildren());
- if((const DataArrayDouble*)_coords)
- ret.push_back((const DataArrayDouble*)_coords);
- if((const DataArrayInt *)_fam_coords)
- ret.push_back((const DataArrayInt *)_fam_coords);
- if((const DataArrayInt *)_num_coords)
- ret.push_back((const DataArrayInt *)_num_coords);
- if((const DataArrayInt *)_rev_num_coords)
- ret.push_back((const DataArrayInt *)_rev_num_coords);
- if((const DataArrayAsciiChar *)_name_coords)
- ret.push_back((const DataArrayAsciiChar *)_name_coords);
- for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();it!=_ms.end();it++)
- if((const MEDFileUMeshSplitL1*) *it)
- ret.push_back((const MEDFileUMeshSplitL1*) *it);
+ std::vector<const BigMemoryObject *> ret(MEDFileMesh::getDirectChildrenWithNull());
+ ret.push_back((const DataArrayDouble*)_coords);
+ ret.push_back((const DataArrayInt *)_fam_coords);
+ ret.push_back((const DataArrayInt *)_num_coords);
+ ret.push_back((const DataArrayInt *)_rev_num_coords);
+ ret.push_back((const DataArrayAsciiChar *)_name_coords);
+ ret.push_back((const PartDefinition *)_part_coords);
+ for(std::vector< MCAuto<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();it!=_ms.end();it++)
+ ret.push_back((const MEDFileUMeshSplitL1*) *it);
return ret;
}
-MEDFileMesh *MEDFileUMesh::shallowCpy() const
+MEDFileUMesh *MEDFileUMesh::shallowCpy() const
{
- MEDCouplingAutoRefCountObjectPtr<MEDFileUMesh> ret=new MEDFileUMesh(*this);
+ MCAuto<MEDFileUMesh> ret(new MEDFileUMesh(*this));
return ret.retn();
}
return new MEDFileUMesh;
}
-MEDFileMesh *MEDFileUMesh::deepCpy() const
+MEDFileUMesh *MEDFileUMesh::deepCopy() const
{
- MEDCouplingAutoRefCountObjectPtr<MEDFileUMesh> ret=new MEDFileUMesh(*this);
+ MCAuto<MEDFileUMesh> ret(new MEDFileUMesh(*this));
+ ret->deepCpyEquivalences(*this);
if((const DataArrayDouble*)_coords)
- ret->_coords=_coords->deepCpy();
+ ret->_coords=_coords->deepCopy();
if((const DataArrayInt*)_fam_coords)
- ret->_fam_coords=_fam_coords->deepCpy();
+ ret->_fam_coords=_fam_coords->deepCopy();
if((const DataArrayInt*)_num_coords)
- ret->_num_coords=_num_coords->deepCpy();
+ ret->_num_coords=_num_coords->deepCopy();
if((const DataArrayInt*)_rev_num_coords)
- ret->_rev_num_coords=_rev_num_coords->deepCpy();
+ ret->_rev_num_coords=_rev_num_coords->deepCopy();
if((const DataArrayAsciiChar*)_name_coords)
- ret->_name_coords=_name_coords->deepCpy();
+ ret->_name_coords=_name_coords->deepCopy();
std::size_t i=0;
- for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();it!=_ms.end();it++,i++)
+ for(std::vector< MCAuto<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();it!=_ms.end();it++,i++)
{
if((const MEDFileUMeshSplitL1 *)(*it))
- ret->_ms[i]=(*it)->deepCpy(ret->_coords);
+ ret->_ms[i]=(*it)->deepCopy(ret->_coords);
}
+ if((const PartDefinition*)_part_coords)
+ ret->_part_coords=_part_coords->deepCopy();
return ret.retn();
}
return false;
}
}
- return true;
+ const PartDefinition *pd0(_part_coords),*pd1(otherC->_part_coords);
+ if(!pd0 && !pd1)
+ return true;
+ if((!pd0 && pd1) || (pd0 && !pd1))
+ {
+ what=std::string("node part def is defined only for one among this or other !");
+ return false;
+ }
+ return pd0->isEqual(pd1,what);
}
/*!
- * Clears redundant attributes of incorporated data arrays.
+ * Check that the current object MEDFileUMesh is consistent. This does not check the optional renumbering of
+ * nodes and cells. This last item is important for SMESH, see checkSMESHConsistency().
+ * \throw if any internal part (i.e. mesh sub-levels and single geometric-type meshes) are inconsistent
+ * \throw if internal family array is inconsistent
+ * \sa checkSMESHConsistency()
*/
-void MEDFileUMesh::clearNonDiscrAttributes() const
+void MEDFileUMesh::checkConsistency() const
{
- MEDFileMesh::clearNonDiscrAttributes();
- const DataArrayDouble *coo1=_coords;
- if(coo1)
- (const_cast<DataArrayDouble *>(coo1))->setName("");//This parameter is not discriminant for comparison
+ if(!_coords || !_coords->isAllocated())
+ {
+ if(!_ms.size())
+ throw INTERP_KERNEL::Exception("MEDFileUMesh::checkConsistency(): coords are null but some mesh parts are present!");
+ if (!_fam_coords)
+ throw INTERP_KERNEL::Exception("MEDFileUMesh::checkConsistency(): coords are null but not the internal node family array!");
+ if (!_num_coords || !_rev_num_coords)
+ throw INTERP_KERNEL::Exception("MEDFileUMesh::checkConsistency(): coords are null but not the internal node numbering array!");
+ }
+ else
+ {
+ int nbCoo = _coords->getNumberOfTuples();
+ if (_fam_coords)
+ _fam_coords->checkNbOfTuplesAndComp(nbCoo,1,"MEDFileUMesh::checkConsistency(): inconsistent internal node family array!");
+ if (_num_coords)
+ {
+ _num_coords->checkNbOfTuplesAndComp(nbCoo,1,"MEDFileUMesh::checkConsistency(): inconsistent internal node numbering array!");
+ int pos;
+ int maxValue=_num_coords->getMaxValue(pos);
+ if (!_rev_num_coords || _rev_num_coords->getNumberOfTuples() != (maxValue+1))
+ throw INTERP_KERNEL::Exception("MEDFileUMesh::checkConsistency(): inconsistent internal revert node numbering array!");
+ }
+ if ((_num_coords && !_rev_num_coords) || (!_num_coords && _rev_num_coords))
+ throw INTERP_KERNEL::Exception("MEDFileUMesh::checkConsistency(): inconsistent internal numbering arrays (one is null)!");
+ if (_num_coords && !_num_coords->hasUniqueValues())
+ throw INTERP_KERNEL::Exception("MEDFileUMesh::checkConsistency(): inconsistent internal node numbering array: duplicates found!");
+ if (_name_coords)
+ _name_coords->checkNbOfTuplesAndComp(nbCoo,MED_SNAME_SIZE,"MEDFileUMesh::checkConsistency(): inconsistent internal coord name array!");
+ // Now sub part check:
+ for (std::vector< MCAuto<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();
+ it != _ms.end(); it++)
+ (*it)->checkConsistency();
+ }
+}
+
+/**
+ * Same as checkConsistency() but also checks that optional entities (edges, faces, volumes) numbers are
+ * consistent, i.e. the numbering is either set to null for all sub-levels (thus letting SMESH numbers the
+ * entities as it likes), or non overlapping between all sub-levels.
+ * \throw if the condition above is not respected
+ */
+void MEDFileUMesh::checkSMESHConsistency() const
+{
+ checkConsistency();
+ // For all sub-levels, numbering is either always null or with void intersection:
+ if (_ms.size())
+ {
+ std::vector< MCAuto<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();
+ std::vector< const DataArrayInt * > v;
+ bool voidOrNot = ((*it)->_num == 0);
+ for (it++; it != _ms.end(); it++)
+ if( ((*it)->_num == 0) != voidOrNot )
+ throw INTERP_KERNEL::Exception("MEDFileUMesh::checkConsistency(): inconsistent numbering between mesh sub-levels!");
+ else if (!voidOrNot)
+ v.push_back((*it)->_num);
+ if (!voidOrNot)
+ {
+ // don't forget the 1st one:
+ v.push_back(_ms[0]->_num);
+ MCAuto<DataArrayInt> inter = DataArrayInt::BuildIntersection(v);
+ if (inter->getNumberOfTuples())
+ throw INTERP_KERNEL::Exception("MEDFileUMesh::checkConsistency(): overlapping entity numbering between mesh sub-levels!");
+ }
+ }
+}
+
+/**
+ * Reset optional node and cell numbering for all sub levels in this. This particularly useful to make
+ * sure SMESH will handle the mesh correctly, as it tries to use those numbers if given.
+ */
+void MEDFileUMesh::clearNodeAndCellNumbers()
+{
+ _num_coords = 0;
+ _rev_num_coords = 0;
+ for (std::vector< MCAuto<MEDFileUMeshSplitL1> >::iterator it=_ms.begin();
+ it != _ms.end(); it++)
+ {
+ (*it)->_num = 0;
+ (*it)->_rev_num = 0;
+ }
+}
+
+/*!
+ * Clears redundant attributes of incorporated data arrays.
+ */
+void MEDFileUMesh::clearNonDiscrAttributes() const
+{
+ MEDFileMesh::clearNonDiscrAttributes();
+ const DataArrayDouble *coo1=_coords;
+ if(coo1)
+ (const_cast<DataArrayDouble *>(coo1))->setName("");//This parameter is not discriminant for comparison
const DataArrayInt *famc1=_fam_coords;
if(famc1)
(const_cast<DataArrayInt *>(famc1))->setName("");//This parameter is not discriminant for comparison
const DataArrayAsciiChar *namc1=_name_coords;
if(namc1)
(const_cast<DataArrayAsciiChar *>(namc1))->setName("");//This parameter is not discriminant for comparison
- for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();it!=_ms.end();it++)
+ for(std::vector< MCAuto<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();it!=_ms.end();it++)
{
const MEDFileUMeshSplitL1 *tmp=(*it);
if(tmp)
void MEDFileUMesh::setName(const std::string& name)
{
- for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileUMeshSplitL1> >::iterator it=_ms.begin();it!=_ms.end();it++)
+ for(std::vector< MCAuto<MEDFileUMeshSplitL1> >::iterator it=_ms.begin();it!=_ms.end();it++)
if((MEDFileUMeshSplitL1 *)(*it)!=0)
(*it)->setName(name);
MEDFileMesh::setName(name);
MEDFileUMesh::MEDFileUMesh(med_idt fid, const std::string& mName, int dt, int it, MEDFileMeshReadSelector *mrs)
try
- {
- loadUMeshFromFile(fid,mName,dt,it,mrs);
- }
+{
+ loadLLWithAdditionalItems(fid,mName,dt,it,mrs);
+}
catch(INTERP_KERNEL::Exception& e)
- {
+{
throw e;
- }
+}
+
+/*!
+ * This method loads only a part of specified cells (given by range of cell ID per geometric type)
+ * See MEDFileUMesh::LoadPartOf for detailed description.
+ *
+ * \sa loadLL
+ */
+void MEDFileUMesh::loadPartUMeshFromFile(med_idt fid, const std::string& mName, const std::vector<INTERP_KERNEL::NormalizedCellType>& types, const std::vector<int>& slicPerTyp, int dt, int it, MEDFileMeshReadSelector *mrs)
+{
+ MEDFileUMeshL2 loaderl2;
+ MEDCoupling::MEDCouplingMeshType meshType;
+ int dummy0,dummy1;
+ std::string dummy2;
+ MEDCoupling::MEDCouplingAxisType dummy3;
+ int mid(MEDFileUMeshL2::GetMeshIdFromName(fid,mName,meshType,dummy3,dummy0,dummy1,dummy2));
+ if(meshType!=UNSTRUCTURED)
+ {
+ std::ostringstream oss; oss << "loadPartUMeshFromFile : Trying to load as unstructured an existing mesh with name '" << mName << "' !";
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
+ }
+ loaderl2.loadPart(fid,mid,mName,types,slicPerTyp,dt,it,mrs);
+ dispatchLoadedPart(fid,loaderl2,mName,mrs);
+}
+
+/*!
+ * \brief Write joints in a file
+ */
+void MEDFileMesh::writeJoints(med_idt fid) const
+{
+ if ( (const MEDFileJoints*) _joints )
+ _joints->write(fid);
+}
+
+/*!
+ * \brief Load joints in a file or use provided ones
+ */
+//================================================================================
+/*!
+ * \brief Load joints in a file or use provided ones
+ * \param [in] fid - MED file descriptor
+ * \param [in] toUseInstedOfReading - optional joints to use instead of reading,
+ * Usually this joints are those just read by another iteration
+ * of namesake mesh, when this method is called by MEDFileMeshMultiTS::New()
+ */
+//================================================================================
+
+void MEDFileMesh::loadJointsFromFile(med_idt fid, MEDFileJoints* toUseInstedOfReading)
+{
+ if ( toUseInstedOfReading )
+ setJoints( toUseInstedOfReading );
+ else
+ _joints = MEDFileJoints::New( fid, _name );
+}
+
+void MEDFileMesh::loadEquivalences(med_idt fid)
+{
+ int nbOfEq(MEDFileEquivalences::PresenceOfEquivalences(fid,_name));
+ if(nbOfEq>0)
+ _equiv=MEDFileEquivalences::Load(fid,nbOfEq,this);
+}
+
+void MEDFileMesh::deepCpyEquivalences(const MEDFileMesh& other)
+{
+ const MEDFileEquivalences *equiv(other._equiv);
+ if(equiv)
+ _equiv=equiv->deepCopy(this);
+}
+
+bool MEDFileMesh::areEquivalencesEqual(const MEDFileMesh *other, std::string& what) const
+{
+ const MEDFileEquivalences *thisEq(_equiv),*otherEq(other->_equiv);
+ if(!thisEq && !otherEq)
+ return true;
+ if(thisEq && otherEq)
+ return thisEq->isEqual(otherEq,what);
+ else
+ {
+ what+="Equivalence differs : defined in this and not in other (or reversely) !";
+ return false;
+ }
+}
+
+void MEDFileMesh::getEquivalencesRepr(std::ostream& oss) const
+{
+ const MEDFileEquivalences *equiv(_equiv);
+ if(!equiv)
+ return ;
+ oss << "(******************************)\n(* EQUIVALENCES OF THE MESH : *)\n(******************************)\n";
+ _equiv->getRepr(oss);
+}
+
+void MEDFileMesh::checkCartesian() const
+{
+ if(getAxisType()!=AX_CART)
+ {
+ std::ostringstream oss; oss << "MEDFileMesh::checkCartesian : request for method that is dedicated to a cartesian convention ! But you are not in cartesian convention (" << DataArray::GetAxisTypeRepr(getAxisType()) << ").";
+ oss << std::endl << "To perform operation you have two possiblities :" << std::endl;
+ oss << " - call setAxisType(AX_CART)" << std::endl;
+ oss << " - call cartesianize()";
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
+ }
+}
+
+/*!
+ * \brief Return number of joints, which is equal to number of adjacent mesh domains
+ */
+int MEDFileMesh::getNumberOfJoints() const
+{
+ return ( (const MEDFileJoints *) _joints ) ? _joints->getNumberOfJoints() : 0;
+}
+
+/*!
+ * \brief Return joints with all adjacent mesh domains
+ */
+MEDFileJoints * MEDFileMesh::getJoints() const
+{
+ return const_cast<MEDFileJoints*>(& (*_joints));
+}
-void MEDFileUMesh::loadUMeshFromFile(med_idt fid, const std::string& mName, int dt, int it, MEDFileMeshReadSelector *mrs)
+void MEDFileMesh::setJoints( MEDFileJoints* joints )
+{
+ if ( joints != _joints )
+ {
+ _joints = joints;
+ if ( joints )
+ joints->incrRef();
+ }
+}
+
+/*!
+ * This method loads \b all \b the \b mesh \a mName in the file with \a fid descriptor.
+ *
+ * \sa loadPartUMeshFromFile
+ */
+void MEDFileUMesh::loadLL(med_idt fid, const std::string& mName, int dt, int it, MEDFileMeshReadSelector *mrs)
{
MEDFileUMeshL2 loaderl2;
- ParaMEDMEM::MEDCouplingMeshType meshType;
+ MEDCoupling::MEDCouplingMeshType meshType;
int dummy0,dummy1;
std::string dummy2;
- int mid=MEDFileUMeshL2::GetMeshIdFromName(fid,mName,meshType,dummy0,dummy1,dummy2);
+ MEDCoupling::MEDCouplingAxisType axType;
+ int mid(MEDFileUMeshL2::GetMeshIdFromName(fid,mName,meshType,axType,dummy0,dummy1,dummy2));
+ setAxisType(axType);
if(meshType!=UNSTRUCTURED)
{
std::ostringstream oss; oss << "Trying to load as unstructured an existing mesh with name '" << mName << "' !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
loaderl2.loadAll(fid,mid,mName,dt,it,mrs);
+ dispatchLoadedPart(fid,loaderl2,mName,mrs);
+}
+
+void MEDFileUMesh::dispatchLoadedPart(med_idt fid, const MEDFileUMeshL2& loaderl2, const std::string& mName, MEDFileMeshReadSelector *mrs)
+{
int lev=loaderl2.getNumberOfLevels();
_ms.resize(lev);
for(int i=0;i<lev;i++)
_num_coords=loaderl2.getCoordsNum();
if(!mrs || mrs->isNodeNameFieldReading())
_name_coords=loaderl2.getCoordsName();
+ _part_coords=loaderl2.getPartDefOfCoo();
computeRevNum();
}
MEDLoaderBase::safeStrCpy(_name.c_str(),MED_NAME_SIZE,maa,_too_long_str);
MEDLoaderBase::safeStrCpy(_desc_name.c_str(),MED_COMMENT_SIZE,desc,_too_long_str);
int spaceDim=coo?coo->getNumberOfComponents():0;
- int mdim=getMeshDimension();
+ int mdim(0);
+ if(!_ms.empty())
+ mdim=getMeshDimension();
INTERP_KERNEL::AutoPtr<char> comp=MEDLoaderBase::buildEmptyString(spaceDim*MED_SNAME_SIZE);
INTERP_KERNEL::AutoPtr<char> unit=MEDLoaderBase::buildEmptyString(spaceDim*MED_SNAME_SIZE);
for(int i=0;i<spaceDim;i++)
MEDLoaderBase::safeStrCpy2(c.c_str(),MED_SNAME_SIZE-1,comp+i*MED_SNAME_SIZE,_too_long_str);//MED_TAILLE_PNOM-1 to avoid to write '\0' on next compo
MEDLoaderBase::safeStrCpy2(u.c_str(),MED_SNAME_SIZE-1,unit+i*MED_SNAME_SIZE,_too_long_str);//MED_TAILLE_PNOM-1 to avoid to write '\0' on next compo
}
- MEDmeshCr(fid,maa,spaceDim,mdim,MED_UNSTRUCTURED_MESH,desc,"",MED_SORT_DTIT,MED_CARTESIAN,comp,unit);
- MEDmeshUniversalNameWr(fid,maa);
+ MEDFILESAFECALLERWR0(MEDmeshCr,(fid,maa,spaceDim,mdim,MED_UNSTRUCTURED_MESH,desc,"",MED_SORT_DTIT,MEDFileMeshL2::TraduceAxisTypeRev(getAxisType()),comp,unit));
+ if(_univ_wr_status)
+ MEDFILESAFECALLERWR0(MEDmeshUniversalNameWr,(fid,maa));
std::string meshName(MEDLoaderBase::buildStringFromFortran(maa,MED_NAME_SIZE));
MEDFileUMeshL2::WriteCoords(fid,meshName,_iteration,_order,_time,_coords,_fam_coords,_num_coords,_name_coords);
- for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();it!=_ms.end();it++)
+ for(std::vector< MCAuto<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();it!=_ms.end();it++)
if((const MEDFileUMeshSplitL1 *)(*it)!=0)
(*it)->write(fid,meshName,mdim);
MEDFileUMeshL2::WriteFamiliesAndGrps(fid,meshName,_families,_groups,_too_long_str);
{
std::vector<int> ret;
int lev=0;
- for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();it!=_ms.end();it++,lev--)
+ for(std::vector< MCAuto<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();it!=_ms.end();it++,lev--)
if((const MEDFileUMeshSplitL1 *)(*it)!=0)
if(!(*it)->empty())
ret.push_back(lev);
if(famCoo)
ret.push_back(1);
int lev=0;
- for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();it!=_ms.end();it++,lev--)
+ for(std::vector< MCAuto<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();it!=_ms.end();it++,lev--)
{
const MEDFileUMeshSplitL1 *cur(*it);
if(cur)
if(numCoo)
ret.push_back(1);
int lev=0;
- for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();it!=_ms.end();it++,lev--)
+ for(std::vector< MCAuto<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();it!=_ms.end();it++,lev--)
{
const MEDFileUMeshSplitL1 *cur(*it);
if(cur)
if(nameCoo)
ret.push_back(1);
int lev=0;
- for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();it!=_ms.end();it++,lev--)
+ for(std::vector< MCAuto<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();it!=_ms.end();it++,lev--)
{
const MEDFileUMeshSplitL1 *cur(*it);
if(cur)
return ret;
}
-/*!
- * Returns all relative mesh levels (**excluding nodes**) where a given group is defined.
- * To include nodes, call getGrpNonEmptyLevelsExt() method.
- * \param [in] grp - the name of the group of interest.
- * \return std::vector<int> - a sequence of the relative dimensions.
- */
-std::vector<int> MEDFileUMesh::getGrpNonEmptyLevels(const std::string& grp) const
-{
- std::vector<std::string> fams=getFamiliesOnGroup(grp);
- return getFamsNonEmptyLevels(fams);
-}
-
-/*!
- * Returns all relative mesh levels (including nodes) where a given group is defined.
- * \param [in] grp - the name of the group of interest.
- * \return std::vector<int> - a sequence of the relative dimensions.
- */
-std::vector<int> MEDFileUMesh::getGrpNonEmptyLevelsExt(const std::string& grp) const
-{
- std::vector<std::string> fams=getFamiliesOnGroup(grp);
- return getFamsNonEmptyLevelsExt(fams);
-}
-
-/*!
- * Returns all relative mesh levels (**excluding nodes**) where a given family is defined.
- * To include nodes, call getFamNonEmptyLevelsExt() method.
- * \param [in] fam - the name of the family of interest.
- * \return std::vector<int> - a sequence of the relative dimensions.
- */
-std::vector<int> MEDFileUMesh::getFamNonEmptyLevels(const std::string& fam) const
-{
- std::vector<std::string> fams(1,std::string(fam));
- return getFamsNonEmptyLevels(fams);
-}
-
-/*!
- * Returns all relative mesh levels (including nodes) where a given family is defined.
- * \param [in] fam - the name of the family of interest.
- * \return std::vector<int> - a sequence of the relative dimensions.
- */
-std::vector<int> MEDFileUMesh::getFamNonEmptyLevelsExt(const std::string& fam) const
-{
- std::vector<std::string> fams(1,std::string(fam));
- return getFamsNonEmptyLevelsExt(fams);
-}
-
-/*!
- * Returns all relative mesh levels (**excluding nodes**) where given groups are defined.
- * To include nodes, call getGrpsNonEmptyLevelsExt() method.
- * \param [in] grps - a sequence of names of the groups of interest.
- * \return std::vector<int> - a sequence of the relative dimensions.
- */
-std::vector<int> MEDFileUMesh::getGrpsNonEmptyLevels(const std::vector<std::string>& grps) const
-{
- std::vector<std::string> fams=getFamiliesOnGroups(grps);
- return getFamsNonEmptyLevels(fams);
-}
-
-/*!
- * Returns all relative mesh levels (including nodes) where given groups are defined.
- * \param [in] grps - a sequence of names of the groups of interest.
- * \return std::vector<int> - a sequence of the relative dimensions.
- */
-std::vector<int> MEDFileUMesh::getGrpsNonEmptyLevelsExt(const std::vector<std::string>& grps) const
-{
- std::vector<std::string> fams=getFamiliesOnGroups(grps);
- return getFamsNonEmptyLevelsExt(fams);
-}
-
/*!
* Returns all relative mesh levels (**excluding nodes**) where given families are defined.
* To include nodes, call getFamsNonEmptyLevelsExt() method.
std::vector<int> MEDFileUMesh::getFamsNonEmptyLevels(const std::vector<std::string>& fams) const
{
std::vector<int> ret;
- std::vector<int> levs=getNonEmptyLevels();
- std::vector<int> famIds=getFamiliesIds(fams);
+ std::vector<int> levs(getNonEmptyLevels());
+ std::vector<int> famIds(getFamiliesIds(fams));
for(std::vector<int>::const_iterator it=levs.begin();it!=levs.end();it++)
if(_ms[-(*it)]->presenceOfOneFams(famIds))
ret.push_back(*it);
*/
std::vector<int> MEDFileUMesh::getFamsNonEmptyLevelsExt(const std::vector<std::string>& fams) const
{
- std::vector<int> ret0=getFamsNonEmptyLevels(fams);
- const DataArrayInt *famCoords=_fam_coords;
+ std::vector<int> ret0(getFamsNonEmptyLevels(fams));
+ const DataArrayInt *famCoords(_fam_coords);
if(!famCoords)
return ret0;
- std::vector<int> famIds=getFamiliesIds(fams);
+ std::vector<int> famIds(getFamiliesIds(fams));
if(famCoords->presenceOfValue(famIds))
{
std::vector<int> ret(ret0.size()+1);
return ret0;
}
-/*!
- * Returns names of groups that partly or fully appear on the level \a meshDimRelToMaxExt.
- * \param [in] meshDimRelToMaxExt - a relative dimension of interest.
- * \return std::vector<std::string> - a sequence of group names at \a meshDimRelToMaxExt
- * level.
- */
-std::vector<std::string> MEDFileUMesh::getGroupsOnSpecifiedLev(int meshDimRelToMaxExt) const
-{
- std::vector<std::string> ret;
- std::vector<std::string> allGrps=getGroupsNames();
- for(std::vector<std::string>::const_iterator it=allGrps.begin();it!=allGrps.end();it++)
- {
- std::vector<int> levs=getGrpNonEmptyLevelsExt((*it));
- if(std::find(levs.begin(),levs.end(),meshDimRelToMaxExt)!=levs.end())
- ret.push_back(*it);
- }
- return ret;
-}
-
int MEDFileUMesh::getMaxAbsFamilyIdInArrays() const
{
int ret=-std::numeric_limits<int>::max(),tmp=-1;
int val=_fam_coords->getMaxValue(tmp);
ret=std::max(ret,std::abs(val));
}
- for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();it!=_ms.end();it++)
+ for(std::vector< MCAuto<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();it!=_ms.end();it++)
{
if((const MEDFileUMeshSplitL1 *)(*it))
{
int val=_fam_coords->getMaxValue(tmp);
ret=std::max(ret,val);
}
- for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();it!=_ms.end();it++)
+ for(std::vector< MCAuto<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();it!=_ms.end();it++)
{
if((const MEDFileUMeshSplitL1 *)(*it))
{
int val=_fam_coords->getMinValue(tmp);
ret=std::min(ret,val);
}
- for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();it!=_ms.end();it++)
+ for(std::vector< MCAuto<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();it!=_ms.end();it++)
{
if((const MEDFileUMeshSplitL1 *)(*it))
{
int MEDFileUMesh::getMeshDimension() const
{
int lev=0;
- for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();it!=_ms.end();it++,lev++)
+ for(std::vector< MCAuto<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();it!=_ms.end();it++,lev++)
if((const MEDFileUMeshSplitL1 *)(*it)!=0)
return (*it)->getMeshDimension()+lev;
throw INTERP_KERNEL::Exception("MEDFileUMesh::getMeshDimension : impossible to find a mesh dimension !");
}
oss << std::endl << std::endl;
getFamilyRepr(oss);
+ getEquivalencesRepr(oss);
return oss.str();
}
{
if(meshDimRelToMaxExt==1)
return _fam_coords;
- const MEDFileUMeshSplitL1 *l1=getMeshAtLevSafe(meshDimRelToMaxExt);
+ const MEDFileUMeshSplitL1 *l1(getMeshAtLevSafe(meshDimRelToMaxExt));
+ return l1->getFamilyField();
+}
+
+DataArrayInt *MEDFileUMesh::getFamilyFieldAtLevel(int meshDimRelToMaxExt)
+{
+ if(meshDimRelToMaxExt==1)
+ return _fam_coords;
+ MEDFileUMeshSplitL1 *l1(getMeshAtLevSafe(meshDimRelToMaxExt));
return l1->getFamilyField();
}
return l1->getNameField();
}
+/*!
+ * This method returns for a specified relative level \a meshDimRelToMaxExt the part effectively read (if the instance is the result of the read of a file).
+ *
+ * \param [in] meshDimRelToMaxExt - the extended relative level for which the part definition is requested.
+ * \param [in] gt - The input geometric type for which the part definition is requested.
+ * \return the part definition owned by \a this. So no need to deallocate the returned instance.
+ */
+const PartDefinition *MEDFileUMesh::getPartDefAtLevel(int meshDimRelToMaxExt, INTERP_KERNEL::NormalizedCellType gt) const
+{
+ if(meshDimRelToMaxExt==1)
+ return _part_coords;
+ const MEDFileUMeshSplitL1 *l1(getMeshAtLevSafe(meshDimRelToMaxExt));
+ return l1->getPartDef(gt);
+}
+
int MEDFileUMesh::getNumberOfNodes() const
{
- const DataArrayDouble *coo=_coords;
+ const DataArrayDouble *coo(_coords);
if(!coo)
throw INTERP_KERNEL::Exception(" MEDFileUMesh::getNumberOfNodes : no coords set !");
return coo->getNumberOfTuples();
}
+int MEDFileUMesh::getNumberOfCellsAtLevel(int meshDimRelToMaxExt) const
+{
+ const MEDFileUMeshSplitL1 *l1(getMeshAtLevSafe(meshDimRelToMaxExt));
+ return l1->getNumberOfCells();
+}
+
+bool MEDFileUMesh::hasImplicitPart() const
+{
+ return false;
+}
+
+int MEDFileUMesh::buildImplicitPartIfAny(INTERP_KERNEL::NormalizedCellType gt) const
+{
+ throw INTERP_KERNEL::Exception("MEDFileUMesh::buildImplicitPartIfAny : unstructured meshes do not have implicit part !");
+}
+
+void MEDFileUMesh::releaseImplicitPartIfAny() const
+{
+}
+
void MEDFileUMesh::whichAreNodesFetched(const MEDFileField1TSStructItem& st, const MEDFileFieldGlobsReal *globs, std::vector<bool>& nodesFetched) const
{
std::size_t sz(st.getNumberOfItems());
else
{
const DataArrayInt *arr(globs->getProfile(st[i].getPflName()));
- MEDCouplingAutoRefCountObjectPtr<MEDCoupling1GTUMesh> m2(dynamic_cast<MEDCoupling1GTUMesh *>(m->buildPartOfMySelf(arr->begin(),arr->end(),true)));
+ MCAuto<MEDCoupling1GTUMesh> m2(dynamic_cast<MEDCoupling1GTUMesh *>(m->buildPartOfMySelf(arr->begin(),arr->end(),true)));
m2->computeNodeIdsAlg(nodesFetched);
}
}
}
+MEDFileMesh *MEDFileUMesh::cartesianize() const
+{
+ if(getAxisType()==AX_CART)
+ {
+ incrRef();
+ return const_cast<MEDFileUMesh *>(this);
+ }
+ else
+ {
+ MCAuto<MEDFileUMesh> ret(new MEDFileUMesh(*this));
+ const DataArrayDouble *coords(_coords);
+ if(!coords)
+ throw INTERP_KERNEL::Exception("MEDFileUMesh::cartesianize : coordinates are null !");
+ MCAuto<DataArrayDouble> coordsCart(_coords->cartesianize(getAxisType()));
+ for(std::vector< MCAuto<MEDFileUMeshSplitL1> >::iterator it=ret->_ms.begin();it!=ret->_ms.end();it++)
+ if((const MEDFileUMeshSplitL1 *)(*it))
+ *it=(*it)->shallowCpyUsingCoords(coordsCart);
+ ret->_coords=coordsCart;
+ ret->setAxisType(AX_CART);
+ return ret.retn();
+ }
+}
+
/*!
* Returns the optional numbers of mesh entities of a given dimension transformed using
* DataArrayInt::invertArrayN2O2O2N().
*/
DataArrayDouble *MEDFileUMesh::getCoords() const
{
- MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> tmp(_coords);
+ checkCartesian();
+ MCAuto<DataArrayDouble> tmp(_coords);
if((DataArrayDouble *)tmp)
{
return tmp;
*/
MEDCouplingUMesh *MEDFileUMesh::getGroup(int meshDimRelToMaxExt, const std::string& grp, bool renum) const
{
+ checkCartesian();
synchronizeTinyInfoOnLeaves();
std::vector<std::string> tmp(1);
tmp[0]=grp;
*/
MEDCouplingUMesh *MEDFileUMesh::getGroups(int meshDimRelToMaxExt, const std::vector<std::string>& grps, bool renum) const
{
+ checkCartesian();
synchronizeTinyInfoOnLeaves();
std::vector<std::string> fams2=getFamiliesOnGroups(grps);
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingUMesh> zeRet=getFamilies(meshDimRelToMaxExt,fams2,renum);
+ MCAuto<MEDCouplingUMesh> zeRet=getFamilies(meshDimRelToMaxExt,fams2,renum);
if(grps.size()==1 && ((MEDCouplingUMesh *)zeRet))
zeRet->setName(grps[0]);
return zeRet.retn();
*/
MEDCouplingUMesh *MEDFileUMesh::getFamily(int meshDimRelToMaxExt, const std::string& fam, bool renum) const
{
+ checkCartesian();
synchronizeTinyInfoOnLeaves();
std::vector<std::string> tmp(1);
tmp[0]=fam;
*/
MEDCouplingUMesh *MEDFileUMesh::getFamilies(int meshDimRelToMaxExt, const std::vector<std::string>& fams, bool renum) const
{
+ checkCartesian();
synchronizeTinyInfoOnLeaves();
if(meshDimRelToMaxExt==1)
{
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> arr=getFamiliesArr(1,fams,renum);
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingUMesh> ret=MEDCouplingUMesh::New();
- MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> c=_coords->selectByTupleId(arr->getConstPointer(),arr->getConstPointer()+arr->getNbOfElems());
+ MCAuto<DataArrayInt> arr=getFamiliesArr(1,fams,renum);
+ MCAuto<MEDCouplingUMesh> ret=MEDCouplingUMesh::New();
+ MCAuto<DataArrayDouble> c=_coords->selectByTupleId(arr->getConstPointer(),arr->getConstPointer()+arr->getNbOfElems());
ret->setCoords(c);
return ret.retn();
}
std::vector<int> famIds=getFamiliesIds(fams);
const MEDFileUMeshSplitL1 *l1=getMeshAtLevSafe(meshDimRelToMaxExt);
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingUMesh> zeRet;
+ MCAuto<MEDCouplingUMesh> zeRet;
if(!famIds.empty())
zeRet=l1->getFamilyPart(&famIds[0],&famIds[0]+famIds.size(),renum);
else
{
if((const DataArrayInt *)_fam_coords)
{
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da;
+ MCAuto<DataArrayInt> da;
if(!famIds.empty())
- da=_fam_coords->getIdsEqualList(&famIds[0],&famIds[0]+famIds.size());
+ da=_fam_coords->findIdsEqualList(&famIds[0],&famIds[0]+famIds.size());
else
- da=_fam_coords->getIdsEqualList(0,0);
+ da=_fam_coords->findIdsEqualList(0,0);
if(renum)
return MEDFileUMeshSplitL1::Renumber(_num_coords,da);
else
* \return MEDCouplingUMesh * - a pointer to MEDCouplingUMesh that the caller is to
* delete using decrRef() as it is no more needed.
* \throw If there are no mesh entities of \a meshDimRelToMaxExt dimension in \a this mesh.
- * \sa getGenMeshAtLevel()
*/
MEDCouplingUMesh *MEDFileUMesh::getMeshAtLevel(int meshDimRelToMaxExt, bool renum) const
{
+ checkCartesian();
synchronizeTinyInfoOnLeaves();
if(meshDimRelToMaxExt==1)
{
if(!renum)
{
MEDCouplingUMesh *umesh=MEDCouplingUMesh::New();
- MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> cc=_coords->deepCpy();
+ MCAuto<DataArrayDouble> cc=_coords->deepCopy();
umesh->setCoords(cc);
MEDFileUMeshSplitL1::ClearNonDiscrAttributes(umesh);
umesh->setName(getName());
return l1->getWholeMesh(renum);
}
-/*!
- * Returns a MEDCouplingUMesh of a given relative dimension.
- * \warning If \a meshDimRelToMaxExt == 1 (which means nodes), the returned mesh **is not
- * valid**. This is a feature, because MEDLoader does not create cells that do not exist!
- * To build a valid MEDCouplingUMesh from the returned one in this case,
- * call MEDCouplingUMesh::Build0DMeshFromCoords().
- * \param [in] meshDimRelToMax - the relative dimension of interest.
- * \param [in] renum - if \c true, the returned mesh is permuted according to the
- * optional numbers of mesh entities.
- * \return MEDCouplingMesh * - a pointer to MEDCouplingUMesh that the caller is to
- * delete using decrRef() as it is no more needed.
- * \throw If there are no mesh entities of \a meshDimRelToMax dimension in \a this mesh.
- * \sa getMeshAtLevel()
- */
-MEDCouplingMesh *MEDFileUMesh::getGenMeshAtLevel(int meshDimRelToMax, bool renum) const
-{
- return getMeshAtLevel(meshDimRelToMax,renum);
-}
-
std::vector<int> MEDFileUMesh::getDistributionOfTypes(int meshDimRelToMax) const
{
const MEDFileUMeshSplitL1 *l1(getMeshAtLevSafe(meshDimRelToMax));
*/
void MEDFileUMesh::forceComputationOfParts() const
{
- for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();it!=_ms.end();it++)
+ for(std::vector< MCAuto<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();it!=_ms.end();it++)
{
const MEDFileUMeshSplitL1 *elt(*it);
if(elt)
*/
std::vector<MEDCoupling1GTUMesh *> MEDFileUMesh::getDirectUndergroundSingleGeoTypeMeshes(int meshDimRelToMax) const
{
+ checkCartesian();
const MEDFileUMeshSplitL1 *sp(getMeshAtLevSafe(meshDimRelToMax));
return sp->getDirectUndergroundSingleGeoTypeMeshes();
}
*/
MEDCoupling1GTUMesh *MEDFileUMesh::getDirectUndergroundSingleGeoTypeMesh(INTERP_KERNEL::NormalizedCellType gt) const
{
- const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(gt);
+ checkCartesian();
+ const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel(gt));
int lev=(int)cm.getDimension()-getMeshDimension();
const MEDFileUMeshSplitL1 *sp(getMeshAtLevSafe(lev));
return sp->getDirectUndergroundSingleGeoTypeMesh(gt);
}
+/*!
+ * This method returns for each geo types in \a this number of cells with this geo type.
+ * This method returns info as a vector of pair. The first element of pair is geo type and the second the number of cells associated.
+ * This method also returns the number of nodes of \a this (key associated is NORM_ERROR)
+ *
+ * \sa getDistributionOfTypes
+ */
+std::vector< std::pair<int,int> > MEDFileUMesh::getAllDistributionOfTypes() const
+{
+ std::vector< std::pair<int,int> > ret;
+ std::vector<int> nel(getNonEmptyLevels());
+ for(std::vector<int>::reverse_iterator it=nel.rbegin();it!=nel.rend();it++)
+ {
+ std::vector<INTERP_KERNEL::NormalizedCellType> gt(getGeoTypesAtLevel(*it));
+ for(std::vector<INTERP_KERNEL::NormalizedCellType>::const_iterator it1=gt.begin();it1!=gt.end();it1++)
+ {
+ int nbCells(getNumberOfCellsWithType(*it1));
+ ret.push_back(std::pair<int,int>(*it1,nbCells));
+ }
+ }
+ ret.push_back(std::pair<int,int>(INTERP_KERNEL::NORM_ERROR,getNumberOfNodes()));
+ return ret;
+}
+
/*!
* Given a relative level \a meshDimRelToMax it returns the sorted vector of geometric types present in \a this.
* \throw if the reqsuested \a meshDimRelToMax does not exist.
return sp->getGeoTypes();
}
+int MEDFileUMesh::getNumberOfCellsWithType(INTERP_KERNEL::NormalizedCellType ct) const
+{
+ const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(ct);
+ const MEDFileUMeshSplitL1 *sp(getMeshAtLevSafe( ((int)cm.getDimension())-getMeshDimension() ));
+ return sp->getNumberOfCellsWithType(ct);
+}
+
/*!
* This method extracts from whole family field ids the part relative to the input parameter \a gt.
* \param [in] gt - the geometric type for which the family field is asked.
return sp->extractNumberFieldOnGeoType(gt);
}
-const MEDFileUMeshSplitL1 *MEDFileUMesh::getMeshAtLevSafe(int meshDimRelToMaxExt) const
-{
+/*!
+ * This method returns for specified geometric type \a gt the relative level to \a this.
+ * If the relative level is empty an exception will be thrown.
+ */
+int MEDFileUMesh::getRelativeLevOnGeoType(INTERP_KERNEL::NormalizedCellType gt) const
+{
+ const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(gt);
+ int ret((int)cm.getDimension()-getMeshDimension());
+ getMeshAtLevSafe(ret);//To test that returned value corresponds to a valid level.
+ return ret;
+}
+
+const MEDFileUMeshSplitL1 *MEDFileUMesh::getMeshAtLevSafe(int meshDimRelToMaxExt) const
+{
if(meshDimRelToMaxExt==1)
throw INTERP_KERNEL::Exception("Dimension request is invalid : asking for node level (1) !");
if(meshDimRelToMaxExt>1)
throw INTERP_KERNEL::Exception("Dimension request is invalid (>1) !");
int tracucedRk=-meshDimRelToMaxExt;
if(tracucedRk>=(int)_ms.size())
- throw INTERP_KERNEL::Exception("Invalid mesh dim relative to max given ! To low !");
+ throw INTERP_KERNEL::Exception("Invalid mesh dim relative to max given ! Too low !");
if((const MEDFileUMeshSplitL1 *)_ms[tracucedRk]==0)
throw INTERP_KERNEL::Exception("On specified lev (or entity) no cells exists !");
return _ms[tracucedRk];
MEDFileUMeshSplitL1 *MEDFileUMesh::getMeshAtLevSafe(int meshDimRelToMaxExt)
{
- if(meshDimRelToMaxExt==1)
+ if(meshDimRelToMaxExt==1)
throw INTERP_KERNEL::Exception("Dimension request is invalid : asking for node level (1) !");
if(meshDimRelToMaxExt>1)
throw INTERP_KERNEL::Exception("Dimension request is invalid (>1) !");
int tracucedRk=-meshDimRelToMaxExt;
if(tracucedRk>=(int)_ms.size())
- throw INTERP_KERNEL::Exception("Invalid mesh dim relative to max given ! To low !");
+ throw INTERP_KERNEL::Exception("Invalid mesh dim relative to max given ! Too low !");
if((const MEDFileUMeshSplitL1 *)_ms[tracucedRk]==0)
throw INTERP_KERNEL::Exception("On specified lev (or entity) no cells exists !");
return _ms[tracucedRk];
if(-meshDimRelToMax>=(int)_ms.size())
throw INTERP_KERNEL::Exception("MEDFileUMesh::checkMeshDimCoherency : The meshdim of mesh is not managed by 'this' !");
int i=0;
- for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();it!=_ms.end();it++,i++)
+ for(std::vector< MCAuto<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();it!=_ms.end();it++,i++)
{
if(((const MEDFileUMeshSplitL1*) (*it))!=0)
{
{
if(!coords)
throw INTERP_KERNEL::Exception("MEDFileUMesh::setCoords : null pointer in input !");
+ if(coords==(DataArrayDouble *)_coords)
+ return ;
coords->checkAllocated();
- int nbOfTuples=coords->getNumberOfTuples();
+ int nbOfTuples(coords->getNumberOfTuples());
_coords=coords;
coords->incrRef();
_fam_coords=DataArrayInt::New();
_fam_coords->alloc(nbOfTuples,1);
_fam_coords->fillWithZero();
- for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileUMeshSplitL1> >::iterator it=_ms.begin();it!=_ms.end();it++)
+ _num_coords=0; _rev_num_coords=0; _name_coords=0;
+ for(std::vector< MCAuto<MEDFileUMeshSplitL1> >::iterator it=_ms.begin();it!=_ms.end();it++)
+ if((MEDFileUMeshSplitL1 *)(*it))
+ (*it)->setCoords(coords);
+}
+
+/*!
+ * Change coords without changing anything concerning families and numbering on nodes.
+ */
+void MEDFileUMesh::setCoordsForced(DataArrayDouble *coords)
+{
+ if(!coords)
+ throw INTERP_KERNEL::Exception("MEDFileUMesh::setCoordsForced : null pointer in input !");
+ if(coords==(DataArrayDouble *)_coords)
+ return ;
+ coords->checkAllocated();
+ int nbOfTuples(coords->getNumberOfTuples());
+ if(_coords.isNull())
+ {
+ _coords=coords;
+ coords->incrRef();
+ }
+ else
+ {
+ int oldNbTuples(_coords->getNumberOfTuples());
+ if(oldNbTuples!=nbOfTuples)
+ throw INTERP_KERNEL::Exception("MEDFileUMesh::setCoordsForced : number of tuples is not the same -> invoke setCoords instead !");
+ _coords=coords;
+ coords->incrRef();
+ }
+ for(std::vector< MCAuto<MEDFileUMeshSplitL1> >::iterator it=_ms.begin();it!=_ms.end();it++)
if((MEDFileUMeshSplitL1 *)(*it))
(*it)->setCoords(coords);
}
for(std::vector<int>::const_iterator it=levs.begin();it!=levs.end();it++)
{
const DataArrayInt *ffield=getFamilyFieldAtLevel(*it);
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ids=ffield->getDifferentValues();
+ MCAuto<DataArrayInt> ids=ffield->getDifferentValues();
std::set<int> res;
std::set_union(ids->begin(),ids->end(),allFamsIds.begin(),allFamsIds.end(),std::inserter(res,res.begin()));
allFamsIds=res;
_groups.erase(*it);
}
-void MEDFileUMesh::duplicateNodesOnM1Group(const std::string& grpNameM1, DataArrayInt *&nodesDuplicated, DataArrayInt *&cellsModified, DataArrayInt *&cellsNotModified)
+/**
+ * \b this must be filled at level 0 and -1, typically the -1 level being (part of) the descending connectivity
+ * of the top level. This method build a "crack", or an inner boundary, in \b this along the group of level -1 named grpNameM1.
+ * The boundary is built according to the following method:
+ * - all nodes along the boundary which are not lying on an internal extremity of the (-1)-level group are duplicated (so the
+ * coordinates array is extended).
+ * - new (-1)-level cells are built lying on those new nodes. So the edges/faces along the group are duplicated. A new group
+ * called "<grpNameM1>_dup" containing the effectively duplicated cells is created. Note that in 3D some cells of the group
+ * might not be duplicated at all.
+ * After this operation a top-level cell bordering the group will loose some neighbors (typically the cell which is on the
+ * other side of the group is no more a neighbor)
+ * - finally, the connectivity of (part of) the top level-cells bordering the group is also modified so that some cells
+ * bordering the newly created boundary use the newly computed nodes.
+ * Finally note that optional cell numbers are also affected by this method and might become invalid for SMESH.
+ * Use clearNodeAndCellNumbers() afterwards to ensure a proper SMESH loading.
+ *
+ * \param[in] grpNameM1 name of the (-1)-level group defining the boundary
+ * \param[out] nodesDuplicated ids of the initial nodes which have been duplicated (and whose copy is put at the end of
+ * the coord array)
+ * \param[out] cellsModified ids of the cells whose connectivity has been modified (to use the newly created nodes)
+ * \param[out] cellsNotModified ids of the rest of cells bordering the new boundary whose connectivity remains unchanged.
+ * \sa clearNodeAndCellNumbers()
+ */
+void MEDFileUMesh::buildInnerBoundaryAlongM1Group(const std::string& grpNameM1, DataArrayInt *&nodesDuplicated,
+ DataArrayInt *&cellsModified, DataArrayInt *&cellsNotModified)
{
+ typedef MCAuto<MEDCouplingUMesh> MUMesh;
+ typedef MCAuto<DataArrayInt> DAInt;
+
std::vector<int> levs=getNonEmptyLevels();
if(std::find(levs.begin(),levs.end(),0)==levs.end() || std::find(levs.begin(),levs.end(),-1)==levs.end())
- throw INTERP_KERNEL::Exception("MEDFileUMesh::duplicateNodesOnM1Group : This method works only for mesh definied on level 0 and -1 !");
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingUMesh> m0=getMeshAtLevel(0);
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingUMesh> m1=getMeshAtLevel(-1);
+ throw INTERP_KERNEL::Exception("MEDFileUMesh::buildInnerBoundaryAlongM1Group : This method works only for mesh definied on level 0 and -1 !");
+ MUMesh m0=getMeshAtLevel(0);
+ MUMesh m1=getMeshAtLevel(-1);
int nbNodes=m0->getNumberOfNodes();
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingUMesh> m11=getGroup(-1,grpNameM1);
+ MUMesh m11=getGroup(-1,grpNameM1);
DataArrayInt *tmp00=0,*tmp11=0,*tmp22=0;
m0->findNodesToDuplicate(*m11,tmp00,tmp11,tmp22);
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> nodeIdsToDuplicate(tmp00);
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> cellsToModifyConn0(tmp11);
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> cellsToModifyConn1(tmp22);
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingUMesh> tmp0=static_cast<MEDCouplingUMesh *>(m0->buildPartOfMySelf(cellsToModifyConn0->begin(),cellsToModifyConn0->end(),true));
+ DAInt nodeIdsToDuplicate(tmp00);
+ DAInt cellsToModifyConn0(tmp11);
+ DAInt cellsToModifyConn1(tmp22);
+ MUMesh tmp0=static_cast<MEDCouplingUMesh *>(m0->buildPartOfMySelf(cellsToModifyConn0->begin(),cellsToModifyConn0->end(),true));
// node renumbering of cells in m1 impacted by duplication of node but not in group 'grpNameM1' on level -1
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> descTmp0=DataArrayInt::New(),descITmp0=DataArrayInt::New(),revDescTmp0=DataArrayInt::New(),revDescITmp0=DataArrayInt::New();
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingUMesh> tmp0Desc=tmp0->buildDescendingConnectivity(descTmp0,descITmp0,revDescTmp0,revDescITmp0);
+ DAInt descTmp0=DataArrayInt::New(),descITmp0=DataArrayInt::New(),revDescTmp0=DataArrayInt::New(),revDescITmp0=DataArrayInt::New();
+ MUMesh tmp0Desc=tmp0->buildDescendingConnectivity(descTmp0,descITmp0,revDescTmp0,revDescITmp0);
descTmp0=0; descITmp0=0; revDescTmp0=0; revDescITmp0=0;
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> cellsInM1ToRenumW2=tmp0Desc->getCellIdsLyingOnNodes(nodeIdsToDuplicate->begin(),nodeIdsToDuplicate->end(),false);
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingUMesh> cellsInM1ToRenumW3=static_cast<MEDCouplingUMesh *>(tmp0Desc->buildPartOfMySelf(cellsInM1ToRenumW2->begin(),cellsInM1ToRenumW2->end(),true));
+ DAInt cellsInM1ToRenumW2=tmp0Desc->getCellIdsLyingOnNodes(nodeIdsToDuplicate->begin(),nodeIdsToDuplicate->end(),false);
+ MUMesh cellsInM1ToRenumW3=static_cast<MEDCouplingUMesh *>(tmp0Desc->buildPartOfMySelf(cellsInM1ToRenumW2->begin(),cellsInM1ToRenumW2->end(),true));
DataArrayInt *cellsInM1ToRenumW4Tmp=0;
m1->areCellsIncludedIn(cellsInM1ToRenumW3,2,cellsInM1ToRenumW4Tmp);
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> cellsInM1ToRenumW4(cellsInM1ToRenumW4Tmp);
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> cellsInM1ToRenumW5=cellsInM1ToRenumW4->getIdsInRange(0,m1->getNumberOfCells());
+ DAInt cellsInM1ToRenumW4(cellsInM1ToRenumW4Tmp);
+ DAInt cellsInM1ToRenumW5=cellsInM1ToRenumW4->findIdsInRange(0,m1->getNumberOfCells());
cellsInM1ToRenumW5->transformWithIndArr(cellsInM1ToRenumW4->begin(),cellsInM1ToRenumW4->end());
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> grpIds=getGroupArr(-1,grpNameM1);
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> cellsInM1ToRenum=cellsInM1ToRenumW5->buildSubstraction(grpIds);
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingUMesh> m1Part=static_cast<MEDCouplingUMesh *>(m1->buildPartOfMySelf(cellsInM1ToRenum->begin(),cellsInM1ToRenum->end(),true));
+ DAInt grpIds=getGroupArr(-1,grpNameM1);
+ DAInt cellsInM1ToRenum=cellsInM1ToRenumW5->buildSubstraction(grpIds);
+ MUMesh m1Part=static_cast<MEDCouplingUMesh *>(m1->buildPartOfMySelf(cellsInM1ToRenum->begin(),cellsInM1ToRenum->end(),true));
m1Part->duplicateNodesInConn(nodeIdsToDuplicate->begin(),nodeIdsToDuplicate->end(),nbNodes);
m1->setPartOfMySelf(cellsInM1ToRenum->begin(),cellsInM1ToRenum->end(),*m1Part);
// end of node renumbering of cells in m1 impacted by duplication of node but not in group of level -1 'grpNameM1'
tmp0->duplicateNodes(nodeIdsToDuplicate->begin(),nodeIdsToDuplicate->end());
m0->setCoords(tmp0->getCoords());
m0->setPartOfMySelf(cellsToModifyConn0->begin(),cellsToModifyConn0->end(),*tmp0);
+ _ms[0]->forceComputationOfParts(); // necessary because we modify the connectivity of some internal part
m1->setCoords(m0->getCoords());
_coords=m0->getCoords(); _coords->incrRef();
- // duplication of cells in group 'grpNameM1' on level -1
+ // duplication of cells in group 'grpNameM1' on level -1, but not duplicating cells for which nothing has changed
m11->duplicateNodesInConn(nodeIdsToDuplicate->begin(),nodeIdsToDuplicate->end(),nbNodes); m11->setCoords(m0->getCoords());
- std::vector<const MEDCouplingUMesh *> v(2); v[0]=m1; v[1]=m11;
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingUMesh> newm1=MEDCouplingUMesh::AggregateSortedByTypeMeshesOnSameCoords(v,tmp00,tmp11);
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> szOfCellGrpOfSameType(tmp00);
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> idInMsOfCellGrpOfSameType(tmp11);
+ DataArrayInt * duplCells;
+ m1->areCellsIncludedIn(m11, 0, duplCells);
+ DAInt zeIds = duplCells->findIdsNotInRange(-1, m1->getNumberOfCells()-1); duplCells->decrRef();
+ MUMesh m11Part=static_cast<MEDCouplingUMesh *>(m11->buildPartOfMySelf(zeIds->begin(),zeIds->end(),true));
+ std::vector<const MEDCouplingUMesh *> v(2); v[0]=m1; v[1]=m11Part;
+ MUMesh newm1=MEDCouplingUMesh::AggregateSortedByTypeMeshesOnSameCoords(v,tmp00,tmp11);
+ DAInt szOfCellGrpOfSameType(tmp00);
+ DAInt idInMsOfCellGrpOfSameType(tmp11);
//
newm1->setName(getName());
const DataArrayInt *fam=getFamilyFieldAtLevel(-1);
if(!fam)
- throw INTERP_KERNEL::Exception("MEDFileUMesh::duplicateNodesOnM1Group : internal problem !");
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> newFam=DataArrayInt::New();
+ throw INTERP_KERNEL::Exception("MEDFileUMesh::buildInnerBoundaryAlongM1Group(): internal error no family field !");
+ DAInt newFam=DataArrayInt::New();
newFam->alloc(newm1->getNumberOfCells(),1);
- int idd=getMaxFamilyId()+1;
+ // Get a new family ID: care must be taken if we need a positive ID or a negative one:
+ // Positive ID for family of nodes, negative for all the rest.
+ int idd;
+ if (m1->getMeshDimension() == 0)
+ idd=getMaxFamilyId()+1;
+ else
+ idd=getMinFamilyId()-1;
int globStart=0,start=0,end,globEnd;
int nbOfChunks=szOfCellGrpOfSameType->getNumberOfTuples();
for(int i=0;i<nbOfChunks;i++)
globEnd=globStart+szOfCellGrpOfSameType->getIJ(i,0);
if(idInMsOfCellGrpOfSameType->getIJ(i,0)==0)
{
- end=start+szOfCellGrpOfSameType->getIJ(i,0);
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> part=fam->selectByTupleId2(start,end,1);
- newFam->setPartOfValues1(part,globStart,globEnd,1,0,1,1,true);
- start=end;
+ end=start+szOfCellGrpOfSameType->getIJ(i,0);
+ DAInt part=fam->selectByTupleIdSafeSlice(start,end,1);
+ newFam->setPartOfValues1(part,globStart,globEnd,1,0,1,1,true);
+ start=end;
+ }
+ else
+ {
+ newFam->setPartOfValuesSimple1(idd,globStart,globEnd,1,0,1,1);
+ }
+ globStart=globEnd;
+ }
+ newm1->setCoords(getCoords());
+ setMeshAtLevel(-1,newm1);
+ setFamilyFieldArr(-1,newFam);
+ std::string grpName2(grpNameM1); grpName2+="_dup";
+ addFamily(grpName2,idd);
+ addFamilyOnGrp(grpName2,grpName2);
+ //
+ fam=_fam_coords;
+ if(fam)
+ {
+ int newNbOfNodes=getCoords()->getNumberOfTuples();
+ newFam=DataArrayInt::New(); newFam->alloc(newNbOfNodes,1);
+ newFam->setPartOfValues1(fam,0,nbNodes,1,0,1,1,true);
+ newFam->setPartOfValuesSimple1(0,nbNodes,newNbOfNodes,1,0,1,1);
+ _fam_coords=newFam;
+ }
+
+ _num_coords = 0;
+ _rev_num_coords = 0;
+ for (std::vector< MCAuto<MEDFileUMeshSplitL1> >::iterator it=_ms.begin();
+ it != _ms.end(); it++)
+ {
+ (*it)->_num = 0;
+ (*it)->_rev_num = 0;
+ }
+ nodesDuplicated=nodeIdsToDuplicate.retn();
+ cellsModified=cellsToModifyConn0.retn();
+ cellsNotModified=cellsToModifyConn1.retn();
+}
+
+/*! Similar to MEDCouplingUMesh::unPolyze(): converts all polygons (if \a this is a 2D mesh) or polyhedrons
+ * (if \a this is a 3D mesh) to cells of classical types. The cells remain correctly sorted by geometric type
+ * in this method.
+ *
+ * \param [out] oldCode retrieves the distribution of types before the call if true is returned
+ * \param [out] newCode etrieves the distribution of types after the call if true is returned
+ * \param [out] o2nRenumCell tells for **all levels** the old 2 new renumbering of cells.
+ *
+ * \return false if no modification has been performed linked to the unpolyzation. Neither cell type, not cell numbers. When false is returned no need of field on cells or on gauss renumbering.
+ * Inversely, if true is returned, it means that distribution of cell by geometric type has changed and field on cell and field on gauss point must be renumbered.
+ */
+bool MEDFileUMesh::unPolyze(std::vector<int>& oldCode, std::vector<int>& newCode, DataArrayInt *& o2nRenumCell)
+{
+ o2nRenumCell=0; oldCode.clear(); newCode.clear();
+ std::vector<int> levs=getNonEmptyLevels();
+ bool ret=false;
+ std::vector< const DataArrayInt* > renumCellsSplited;//same than memorySaverIfThrow
+ std::vector< MCAuto<DataArrayInt> > memorySaverIfThrow;//same than renumCellsSplited only in case of throw
+ int start=0;
+ int end=0;
+ for(std::vector<int>::reverse_iterator it=levs.rbegin();it!=levs.rend();it++)
+ {
+ MCAuto<MEDCouplingUMesh> m=getMeshAtLevel(*it);
+ std::vector<int> code1=m->getDistributionOfTypes();
+ end=PutInThirdComponentOfCodeOffset(code1,start);
+ oldCode.insert(oldCode.end(),code1.begin(),code1.end());
+ bool hasChanged=m->unPolyze();
+ DataArrayInt *fake=0;
+ MCAuto<DataArrayInt> o2nCellsPart=m->getLevArrPerCellTypes(MEDCouplingUMesh::MEDMEM_ORDER,
+ MEDCouplingUMesh::MEDMEM_ORDER+MEDCouplingUMesh::N_MEDMEM_ORDER,fake);
+ fake->decrRef();
+ renumCellsSplited.push_back(o2nCellsPart); memorySaverIfThrow.push_back(o2nCellsPart);
+ if(hasChanged)
+ {
+ MCAuto<DataArrayInt> o2nCellsPart2=o2nCellsPart->buildPermArrPerLevel();
+ m->renumberCells(o2nCellsPart2->getConstPointer(),false);
+ ret=true;
+ MCAuto<DataArrayInt> famField2,numField2;
+ const DataArrayInt *famField=getFamilyFieldAtLevel(*it); if(famField) { famField->incrRef(); famField2=const_cast<DataArrayInt *>(famField); }
+ const DataArrayInt *numField=getNumberFieldAtLevel(*it); if(numField) { numField->incrRef(); numField2=const_cast<DataArrayInt *>(numField); }
+ setMeshAtLevel(*it,m);
+ std::vector<int> code2=m->getDistributionOfTypes();
+ end=PutInThirdComponentOfCodeOffset(code2,start);
+ newCode.insert(newCode.end(),code2.begin(),code2.end());
+ //
+ if(o2nCellsPart2->isIota(o2nCellsPart2->getNumberOfTuples()))
+ continue;
+ if(famField)
+ {
+ MCAuto<DataArrayInt> newFamField=famField->renumber(o2nCellsPart2->getConstPointer());
+ setFamilyFieldArr(*it,newFamField);
+ }
+ if(numField)
+ {
+ MCAuto<DataArrayInt> newNumField=numField->renumber(o2nCellsPart2->getConstPointer());
+ setRenumFieldArr(*it,newNumField);
+ }
+ }
+ else
+ {
+ newCode.insert(newCode.end(),code1.begin(),code1.end());
+ }
+ start=end;
+ }
+ if(ret)
+ {
+ MCAuto<DataArrayInt> renumCells=DataArrayInt::Aggregate(renumCellsSplited);
+ MCAuto<DataArrayInt> o2nRenumCellRet=renumCells->buildPermArrPerLevel();
+ o2nRenumCell=o2nRenumCellRet.retn();
+ }
+ return ret;
+}
+
+/*! \cond HIDDEN_ITEMS */
+struct MEDLoaderAccVisit1
+{
+ MEDLoaderAccVisit1():_new_nb_of_nodes(0) { }
+ int operator()(bool val) { return val?_new_nb_of_nodes++:-1; }
+ int _new_nb_of_nodes;
+};
+/*! \endcond */
+
+/*!
+ * Array returned is the correspondance in \b old \b to \b new format. The returned array is newly created and should be dealt by the caller.
+ * The maximum value stored in returned array is the number of nodes of \a this minus 1 after call of this method.
+ * The size of returned array is the number of nodes of the old (previous to the call of this method) number of nodes.
+ * -1 values in returned array means that the corresponding old node is no more used.
+ *
+ * \return newly allocated array containing correspondance in \b old \b to \b new format. If all nodes in \a this are fetched \c NULL pointer is returned and nothing
+ * is modified in \a this.
+ * \throw If no coordinates are set in \a this or if there is in any available mesh in \a this a cell having a nodal connectivity containing a node id not in the range of
+ * set coordinates.
+ */
+DataArrayInt *MEDFileUMesh::zipCoords()
+{
+ const DataArrayDouble *coo(getCoords());
+ if(!coo)
+ throw INTERP_KERNEL::Exception("MEDFileUMesh::zipCoords : no coordinates set in this !");
+ int nbOfNodes(coo->getNumberOfTuples());
+ std::vector<bool> nodeIdsInUse(nbOfNodes,false);
+ std::vector<int> neLevs(getNonEmptyLevels());
+ for(std::vector<int>::const_iterator lev=neLevs.begin();lev!=neLevs.end();lev++)
+ {
+ const MEDFileUMeshSplitL1 *zeLev(getMeshAtLevSafe(*lev));
+ if(zeLev->isMeshStoredSplitByType())
+ {
+ std::vector<MEDCoupling1GTUMesh *> ms(zeLev->getDirectUndergroundSingleGeoTypeMeshes());
+ for(std::vector<MEDCoupling1GTUMesh *>::const_iterator it=ms.begin();it!=ms.end();it++)
+ if(*it)
+ (*it)->computeNodeIdsAlg(nodeIdsInUse);
+ }
+ else
+ {
+ MCAuto<MEDCouplingUMesh> mesh(zeLev->getWholeMesh(false));
+ mesh->computeNodeIdsAlg(nodeIdsInUse);
+ }
+ }
+ int nbrOfNodesInUse((int)std::count(nodeIdsInUse.begin(),nodeIdsInUse.end(),true));
+ if(nbrOfNodesInUse==nbOfNodes)
+ return 0;//no need to update _part_coords
+ MCAuto<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(nbOfNodes,1);
+ std::transform(nodeIdsInUse.begin(),nodeIdsInUse.end(),ret->getPointer(),MEDLoaderAccVisit1());
+ MCAuto<DataArrayInt> ret2(ret->invertArrayO2N2N2OBis(nbrOfNodesInUse));
+ MCAuto<DataArrayDouble> newCoords(coo->selectByTupleIdSafe(ret2->begin(),ret2->end()));
+ MCAuto<DataArrayInt> newFamCoords;
+ MCAuto<DataArrayAsciiChar> newNameCoords;
+ if((const DataArrayInt *)_fam_coords)
+ newFamCoords=_fam_coords->selectByTupleIdSafe(ret2->begin(),ret2->end());
+ MCAuto<DataArrayInt> newNumCoords;
+ if((const DataArrayInt *)_num_coords)
+ newNumCoords=_num_coords->selectByTupleIdSafe(ret2->begin(),ret2->end());
+ if((const DataArrayAsciiChar *)_name_coords)
+ newNameCoords=static_cast<DataArrayAsciiChar *>(_name_coords->selectByTupleIdSafe(ret2->begin(),ret2->end()));
+ _coords=newCoords; _fam_coords=newFamCoords; _num_coords=newNumCoords; _name_coords=newNameCoords; _rev_num_coords=0;
+ for(std::vector< MCAuto<MEDFileUMeshSplitL1> >::iterator it=_ms.begin();it!=_ms.end();it++)
+ {
+ if((MEDFileUMeshSplitL1*)*it)
+ {
+ (*it)->renumberNodesInConn(ret->begin());
+ (*it)->setCoords(_coords);
+ }
+ }
+ // updates _part_coords
+ const PartDefinition *pc(_part_coords);
+ if(pc)
+ {
+ MCAuto<PartDefinition> tmpPD(DataArrayPartDefinition::New(ret2));
+ _part_coords=tmpPD->composeWith(pc);
+ }
+ return ret.retn();
+}
+
+/*!
+ * This method is a const method. It computes the minimal set of node ids covered by the cell extraction of \a this.
+ * The extraction of \a this is specified by the extractDef \a input map.
+ * This map tells for each level of cells, the cells kept in the extraction.
+ *
+ * \return - a new reference of DataArrayInt that represents sorted node ids, the extraction is lying on.
+ * \sa MEDFileField1TS::extractPart, MEDFileUMesh::extractPart
+ */
+DataArrayInt *MEDFileUMesh::deduceNodeSubPartFromCellSubPart(const std::map<int, MCAuto<DataArrayInt> >& extractDef) const
+{
+ std::vector<int> levs(getNonEmptyLevels());
+ std::vector<bool> fetchedNodes(getNumberOfNodes(),false);
+ for(std::map<int, MCAuto<DataArrayInt> >::const_iterator it=extractDef.begin();it!=extractDef.end();it++)
+ {
+ if((*it).first>1)
+ throw INTERP_KERNEL::Exception("MEDFileUMesh::deduceNodeSubPartFromCellSubPart : invalid key ! Must be <=1 !");
+ if((*it).second.isNull())
+ throw INTERP_KERNEL::Exception("MEDFileUMesh::deduceNodeSubPartFromCellSubPart : presence of a value with null pointer !");
+ if((*it).first==1)
+ continue;
+ if(std::find(levs.begin(),levs.end(),(*it).first)==levs.end())
+ {
+ std::ostringstream oss; oss << "MEDFileUMesh::deduceNodeSubPartFromCellSubPart : invalid level " << (*it).first << " ! Not present in this !";
+ throw INTERP_KERNEL::Exception(oss.str());
+ }
+ MCAuto<MEDCouplingUMesh> m(getMeshAtLevel((*it).first));
+ MCAuto<MEDCouplingUMesh> mPart(m->buildPartOfMySelf((*it).second->begin(),(*it).second->end(),true));
+ mPart->computeNodeIdsAlg(fetchedNodes);
+ }
+ return DataArrayInt::BuildListOfSwitchedOn(fetchedNodes);
+}
+
+/*!
+ * This method returns a new MEDFileUMesh that is the result of the extraction of cells/nodes in \a this.
+ *
+ * \return - a new reference of MEDFileUMesh
+ * \sa MEDFileUMesh::deduceNodeSubPartFromCellSubPart, MEDFileFields::extractPart
+ */
+MEDFileUMesh *MEDFileUMesh::extractPart(const std::map<int, MCAuto<DataArrayInt> >& extractDef) const
+{
+ MCAuto<MEDFileUMesh> ret(MEDFileUMesh::New()); ret->setName(getName()); ret->copyFamGrpMapsFrom(*this);
+ std::vector<int> levs(getNonEmptyLevels());
+ for(std::map<int, MCAuto<DataArrayInt> >::const_iterator it=extractDef.begin();it!=extractDef.end();it++)
+ {
+ if((*it).first>1)
+ throw INTERP_KERNEL::Exception("MEDFileUMesh::extractPart : invalid key ! Must be <=1 !");
+ if((*it).second.isNull())
+ throw INTERP_KERNEL::Exception("MEDFileUMesh::extractPart : presence of a value with null pointer !");
+ if((*it).first==1)
+ continue;
+ if(std::find(levs.begin(),levs.end(),(*it).first)==levs.end())
+ {
+ std::ostringstream oss; oss << "MEDFileUMesh::extractPart : invalid level " << (*it).first << " ! Not present in this !";
+ throw INTERP_KERNEL::Exception(oss.str());
+ }
+ MCAuto<MEDCouplingUMesh> m(getMeshAtLevel((*it).first));
+ MCAuto<MEDCouplingUMesh> mPart(m->buildPartOfMySelf((*it).second->begin(),(*it).second->end(),true));
+ ret->setMeshAtLevel((*it).first,mPart);
+ const DataArrayInt *fam(getFamilyFieldAtLevel((*it).first)),*num(getNumberFieldAtLevel((*it).first));
+ if(fam)
+ {
+ MCAuto<DataArrayInt> famPart(fam->selectByTupleIdSafe((*it).second->begin(),(*it).second->end()));
+ ret->setFamilyFieldArr((*it).first,famPart);
+ }
+ if(num)
+ {
+ MCAuto<DataArrayInt> numPart(num->selectByTupleIdSafe((*it).second->begin(),(*it).second->end()));
+ ret->setFamilyFieldArr((*it).first,numPart);
+ }
+ }
+ std::map<int, MCAuto<DataArrayInt> >::const_iterator it2(extractDef.find(1));
+ if(it2!=extractDef.end())
+ {
+ const DataArrayDouble *coo(ret->getCoords());
+ if(!coo)
+ throw INTERP_KERNEL::Exception("MEDFileUMesh::extractPart : trying to extract nodes whereas there is no nodes !");
+ MCAuto<DataArrayInt> o2nNodes(((*it2).second)->invertArrayN2O2O2N(coo->getNumberOfTuples()));
+ MCAuto<DataArrayDouble> cooPart(coo->selectByTupleIdSafe((*it2).second->begin(),(*it2).second->end()));
+ ret->setCoords(cooPart);
+ const DataArrayInt *fam(getFamilyFieldAtLevel(1)),*num(getNumberFieldAtLevel(1));
+ if(fam)
+ {
+ MCAuto<DataArrayInt> famPart(fam->selectByTupleIdSafe((*it2).second->begin(),(*it2).second->end()));
+ ret->setFamilyFieldArr(1,famPart);
+ }
+ if(num)
+ {
+ MCAuto<DataArrayInt> numPart(num->selectByTupleIdSafe((*it2).second->begin(),(*it2).second->end()));
+ ret->setFamilyFieldArr(1,numPart);
+ }
+ for(std::map<int, MCAuto<DataArrayInt> >::const_iterator it3=extractDef.begin();it3!=extractDef.end();it3++)
+ {
+ if((*it3).first==1)
+ continue;
+ MCAuto<MEDCouplingUMesh> m(ret->getMeshAtLevel((*it3).first));
+ m->renumberNodesInConn(o2nNodes->begin());
+ ret->setMeshAtLevel((*it3).first,m);
+ }
+ }
+ return ret.retn();
+}
+
+/*!
+ * This method performs an extrusion along a path defined by \a m1D.
+ * \a this is expected to be a mesh with max mesh dimension equal to 2.
+ * \a m1D is expected to be a mesh with space dimesion equal to 3 and mesh dimension equal to 1.
+ * Mesh dimensions of returned mesh is incremented by one compared to thoose in \a this.
+ * This method scans all levels in \a this
+ * and put them in the returned mesh. All groups in \a this are also put in the returned mesh.
+ *
+ * \param [in] m1D - the mesh defining the extrusion path.
+ * \param [in] policy - defines the policy of extrusion (see MEDCouplingUMesh::buildExtrudedMesh for more details)
+ * \return - a new reference on mesh (you have to deal with using decrRef). The returned mesh will have the same name than \a this.
+ *
+ * \sa MEDCouplingUMesh::buildExtrudedMesh
+ */
+MEDFileUMesh *MEDFileUMesh::buildExtrudedMesh(const MEDCouplingUMesh *m1D, int policy) const
+{
+ checkCartesian();
+ if(getMeshDimension()!=2)
+ throw INTERP_KERNEL::Exception("MEDFileUMesh::buildExtrudedMesh : this is expected to be with mesh dimension equal to 2 !");
+ MCAuto<MEDFileUMesh> ret(MEDFileUMesh::New());
+ m1D->checkConsistencyLight();
+ if(m1D->getMeshDimension()!=1)
+ throw INTERP_KERNEL::Exception("MEDFileUMesh::buildExtrudedMesh : input mesh must have a mesh dimension equal to one !");
+ int nbRep(m1D->getNumberOfCells());
+ std::vector<int> levs(getNonEmptyLevels());
+ std::vector<std::string> grps(getGroupsNames());
+ std::vector< MCAuto<MEDCouplingUMesh> > zeList;
+ DataArrayDouble *coords(0);
+ std::size_t nbOfLevsOut(levs.size()+1);
+ std::vector< MCAuto<DataArrayInt> > o2ns(nbOfLevsOut);
+ for(std::vector<int>::const_iterator lev=levs.begin();lev!=levs.end();lev++)
+ {
+ MCAuto<MEDCouplingUMesh> item(getMeshAtLevel(*lev));
+ item=item->clone(false);
+ item->changeSpaceDimension(3+(*lev),0.);//no problem non const but change DataArrayDouble for coordinates do not alter data
+ MCAuto<MEDCouplingUMesh> tmp(static_cast<MEDCouplingUMesh *>(m1D->deepCopy()));
+ tmp->changeSpaceDimension(3+(*lev),0.);
+ MCAuto<MEDCouplingUMesh> elt(item->buildExtrudedMesh(tmp,policy));
+ zeList.push_back(elt);
+ if(*lev==0)
+ coords=elt->getCoords();
+ }
+ if(!coords)
+ throw INTERP_KERNEL::Exception("MEDFileUMesh::buildExtrudedMesh : internal error !");
+ for(std::vector< MCAuto<MEDCouplingUMesh> >::iterator it=zeList.begin();it!=zeList.end();it++)
+ {
+ (*it)->setName(getName());
+ (*it)->setCoords(coords);
+ }
+ for(std::size_t ii=0;ii!=zeList.size();ii++)
+ {
+ int lev(levs[ii]);
+ MCAuto<MEDCouplingUMesh> elt(zeList[ii]);
+ if(lev<=-1)
+ {
+ MCAuto<MEDCouplingUMesh> elt1(getMeshAtLevel(lev+1));
+ MCAuto<MEDCouplingUMesh> elt2(elt1->clone(false));
+ MCAuto<DataArrayInt> tmp(elt2->getNodalConnectivity()->deepCopy());
+ elt2->setConnectivity(tmp,elt2->getNodalConnectivityIndex());
+ elt2->shiftNodeNumbersInConn(nbRep*elt1->getNumberOfNodes());
+ elt1->setCoords(elt->getCoords()); elt2->setCoords(elt->getCoords());
+ std::vector<const MEDCouplingUMesh *> elts(3);
+ elts[0]=elt; elts[1]=elt1; elts[2]=elt2;
+ elt=MEDCouplingUMesh::MergeUMeshesOnSameCoords(elts);
+ elt->setName(getName());
+ }
+ //
+ o2ns[ii]=elt->sortCellsInMEDFileFrmt();
+ ret->setMeshAtLevel(lev,elt);
+ }
+ MCAuto<MEDCouplingUMesh> endLev(getMeshAtLevel(levs.back())),endLev2;
+ endLev=endLev->clone(false); endLev->setCoords(coords);
+ MCAuto<DataArrayInt> tmp(endLev->getNodalConnectivity()->deepCopy());
+ endLev2=endLev->clone(false); endLev2->setConnectivity(tmp,endLev->getNodalConnectivityIndex());
+ endLev2->shiftNodeNumbersInConn(nbRep*getNumberOfNodes());
+ endLev=MEDCouplingUMesh::MergeUMeshesOnSameCoords(endLev,endLev2);
+ o2ns[levs.size()]=endLev->sortCellsInMEDFileFrmt();
+ endLev->setName(getName());
+ ret->setMeshAtLevel(levs.back()-1,endLev);
+ //
+ for(std::size_t ii=0;ii!=zeList.size();ii++)
+ {
+ int lev(levs[ii]);
+ std::vector< MCAuto<DataArrayInt> > outGrps;
+ std::vector< const DataArrayInt * > outGrps2;
+ if(lev<=-1)
+ {
+ for(std::vector<std::string>::const_iterator grp=grps.begin();grp!=grps.end();grp++)
+ {
+ MCAuto<DataArrayInt> grpArr(getGroupArr(lev+1,*grp));
+ if(!grpArr->empty())
+ {
+ MCAuto<DataArrayInt> grpArr1(grpArr->deepCopy()),grpArr2(grpArr->deepCopy());
+ int offset0(zeList[ii]->getNumberOfCells());
+ int offset1(offset0+getNumberOfCellsAtLevel(lev+1));
+ grpArr1->applyLin(1,offset0); grpArr2->applyLin(1,offset1);
+ std::ostringstream oss; oss << grpArr2->getName() << "_top";
+ grpArr2->setName(oss.str());
+ grpArr1->transformWithIndArr(o2ns[ii]->begin(),o2ns[ii]->end());
+ grpArr2->transformWithIndArr(o2ns[ii]->begin(),o2ns[ii]->end());
+ outGrps.push_back(grpArr1); outGrps.push_back(grpArr2);
+ outGrps2.push_back(grpArr1); outGrps2.push_back(grpArr2);
+ }
+ }
+ }
+ //
+ for(std::vector<std::string>::const_iterator grp=grps.begin();grp!=grps.end();grp++)
+ {
+ MCAuto<DataArrayInt> grpArr(getGroupArr(lev,*grp));
+ if(!grpArr->empty())
+ {
+ int nbCellsB4Extrusion(getNumberOfCellsAtLevel(lev));
+ std::vector< MCAuto<DataArrayInt> > grpArrs(nbRep);
+ std::vector< const DataArrayInt *> grpArrs2(nbRep);
+ for(int iii=0;iii<nbRep;iii++)
+ {
+ grpArrs[iii]=grpArr->deepCopy(); grpArrs[iii]->applyLin(1,iii*nbCellsB4Extrusion);
+ grpArrs2[iii]=grpArrs[iii];
+ }
+ MCAuto<DataArrayInt> grpArrExt(DataArrayInt::Aggregate(grpArrs2));
+ grpArrExt->transformWithIndArr(o2ns[ii]->begin(),o2ns[ii]->end());
+ std::ostringstream grpName; grpName << *grp << "_extruded";
+ grpArrExt->setName(grpName.str());
+ outGrps.push_back(grpArrExt);
+ outGrps2.push_back(grpArrExt);
+ }
+ }
+ ret->setGroupsAtLevel(lev,outGrps2);
+ }
+ std::vector< MCAuto<DataArrayInt> > outGrps;
+ std::vector< const DataArrayInt * > outGrps2;
+ for(std::vector<std::string>::const_iterator grp=grps.begin();grp!=grps.end();grp++)
+ {
+ MCAuto<DataArrayInt> grpArr1(getGroupArr(levs.back(),*grp));
+ if(grpArr1->empty())
+ continue;
+ MCAuto<DataArrayInt> grpArr2(grpArr1->deepCopy());
+ std::ostringstream grpName; grpName << *grp << "_top";
+ grpArr2->setName(grpName.str());
+ grpArr2->applyLin(1,getNumberOfCellsAtLevel(levs.back()));
+ outGrps.push_back(grpArr1); outGrps.push_back(grpArr2);
+ outGrps2.push_back(grpArr1); outGrps2.push_back(grpArr2);
+ }
+ ret->setGroupsAtLevel(levs.back()-1,outGrps2);
+ return ret.retn();
+}
+
+/*!
+ * This method converts all linear cells in \a this into quadratic cells (following the \a conversionType policy).
+ * All the cells converted are put in the returned instance. This method applies all the groups and families in \a this to returned instance.
+ * Groups on nodes and families on nodes are copied directly to the returned instance without transformation.
+ *
+ * \param [in] conversionType - conversionType specifies the type of conversion expected. Only 0 (default) and 1 are supported presently. 0 those that creates the 'most' simple
+ * corresponding quadratic cells. 1 is those creating the 'most' complex.
+ * \param [in] eps - detection threshold for coordinates.
+ * \return A new instance that is the result of the conversion. The caller has the ownership of this returned instance.
+ *
+ * \sa MEDCouplingUMesh::convertLinearCellsToQuadratic , quadraticToLinear
+ */
+MEDFileUMesh *MEDFileUMesh::linearToQuadratic(int conversionType, double eps) const
+{
+ checkCartesian();
+ MCAuto<MEDFileUMesh> ret(MEDFileUMesh::New());
+ int initialNbNodes(getNumberOfNodes());
+ MCAuto<MEDCouplingUMesh> m0Tmp(getMeshAtLevel(0));
+ MCAuto<MEDCouplingUMesh> m0(dynamic_cast<MEDCouplingUMesh *>(m0Tmp->deepCopy()));
+ {
+ MCAuto<DataArrayInt> notUsed(m0->convertLinearCellsToQuadratic(conversionType));
+ }
+ DataArrayDouble *zeCoords(m0->getCoords());
+ ret->setMeshAtLevel(0,m0);
+ std::vector<int> levs(getNonEmptyLevels());
+ const DataArrayInt *famField(getFamilyFieldAtLevel(0));
+ if(famField)
+ {
+ MCAuto<DataArrayInt> famFieldCpy(famField->deepCopy());
+ ret->setFamilyFieldArr(0,famFieldCpy);
+ }
+ famField=getFamilyFieldAtLevel(1);
+ if(famField)
+ {
+ MCAuto<DataArrayInt> fam(DataArrayInt::New()); fam->alloc(zeCoords->getNumberOfTuples(),1);
+ fam->fillWithZero();
+ fam->setPartOfValues1(famField,0,initialNbNodes,1,0,1,1);
+ ret->setFamilyFieldArr(1,fam);
+ }
+ ret->copyFamGrpMapsFrom(*this);
+ MCAuto<DataArrayDouble> partZeCoords(zeCoords->selectByTupleIdSafeSlice(initialNbNodes,zeCoords->getNumberOfTuples(),1));
+ for(std::vector<int>::const_iterator lev=levs.begin();lev!=levs.end();lev++)
+ {
+ if(*lev==0)
+ continue;
+ MCAuto<MEDCouplingUMesh> m1Tmp(getMeshAtLevel(*lev));
+ MCAuto<MEDCouplingUMesh> m1(dynamic_cast<MEDCouplingUMesh *>(m1Tmp->deepCopy()));
+ if(m1->getMeshDimension()!=0)
+ {
+ {
+ MCAuto<DataArrayInt> notUsed(m1->convertLinearCellsToQuadratic(conversionType));
+ }//kill unused notUsed var
+ MCAuto<DataArrayDouble> m1Coords(m1->getCoords()->selectByTupleIdSafeSlice(initialNbNodes,m1->getNumberOfNodes(),1));
+ DataArrayInt *b(0);
+ bool a(partZeCoords->areIncludedInMe(m1Coords,eps,b));
+ MCAuto<DataArrayInt> bSafe(b);
+ if(!a)
+ {
+ std::ostringstream oss; oss << "MEDFileUMesh::linearCellsToQuadratic : for level " << *lev << " problem to identify nodes generated !";
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
+ }
+ b->applyLin(1,initialNbNodes);
+ MCAuto<DataArrayInt> l0(DataArrayInt::New()); l0->alloc(initialNbNodes,1); l0->iota();
+ std::vector<const DataArrayInt *> v(2); v[0]=l0; v[1]=b;
+ MCAuto<DataArrayInt> renum(DataArrayInt::Aggregate(v));
+ m1->renumberNodesInConn(renum->begin());
+ }
+ m1->setCoords(zeCoords);
+ ret->setMeshAtLevel(*lev,m1);
+ famField=getFamilyFieldAtLevel(*lev);
+ if(famField)
+ {
+ MCAuto<DataArrayInt> famFieldCpy(famField->deepCopy());
+ ret->setFamilyFieldArr(*lev,famFieldCpy);
+ }
+ }
+ return ret.retn();
+}
+
+/*!
+ * This method converts all quadratic cells in \a this into linear cells.
+ * All the cells converted are put in the returned instance. This method applies all the groups and families in \a this to returned instance.
+ * Groups on nodes and families on nodes are copied directly to the returned instance without transformation.
+ *
+ * \param [in] eps - detection threshold for coordinates.
+ * \return A new instance that is the result of the conversion. The caller has the ownership of this returned instance.
+ *
+ * \sa MEDCouplingUMesh::convertLinearCellsToQuadratic , linearToQuadratic
+ */
+MEDFileUMesh *MEDFileUMesh::quadraticToLinear(double eps) const
+{
+ checkCartesian();
+ MCAuto<MEDFileUMesh> ret(MEDFileUMesh::New());
+ MCAuto<MEDCouplingUMesh> m0Tmp(getMeshAtLevel(0));
+ MCAuto<MEDCouplingUMesh> m0(dynamic_cast<MEDCouplingUMesh *>(m0Tmp->deepCopy()));
+ m0->convertQuadraticCellsToLinear();
+ m0->zipCoords();
+ DataArrayDouble *zeCoords(m0->getCoords());
+ ret->setMeshAtLevel(0,m0);
+ std::vector<int> levs(getNonEmptyLevels());
+ const DataArrayInt *famField(getFamilyFieldAtLevel(0));
+ if(famField)
+ {
+ MCAuto<DataArrayInt> famFieldCpy(famField->deepCopy());
+ ret->setFamilyFieldArr(0,famFieldCpy);
+ }
+ famField=getFamilyFieldAtLevel(1);
+ if(famField)
+ {
+ MCAuto<DataArrayInt> fam(famField->selectByTupleIdSafeSlice(0,zeCoords->getNumberOfTuples(),1));
+ ret->setFamilyFieldArr(1,fam);
+ }
+ ret->copyFamGrpMapsFrom(*this);
+ for(std::vector<int>::const_iterator lev=levs.begin();lev!=levs.end();lev++)
+ {
+ if(*lev==0)
+ continue;
+ MCAuto<MEDCouplingUMesh> m1Tmp(getMeshAtLevel(*lev));
+ MCAuto<MEDCouplingUMesh> m1(dynamic_cast<MEDCouplingUMesh *>(m1Tmp->deepCopy()));
+ m1->convertQuadraticCellsToLinear();
+ m1->zipCoords();
+ DataArrayInt *b(0);
+ bool a(zeCoords->areIncludedInMe(m1->getCoords(),eps,b));
+ MCAuto<DataArrayInt> bSafe(b);
+ if(!a)
+ {
+ std::ostringstream oss; oss << "MEDFileUMesh::quadraticToLinear : for level " << *lev << " problem to identify nodes generated !";
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
}
- else
+ m1->renumberNodesInConn(b->begin());
+ m1->setCoords(zeCoords);
+ ret->setMeshAtLevel(*lev,m1);
+ famField=getFamilyFieldAtLevel(*lev);
+ if(famField)
{
- newFam->setPartOfValuesSimple1(idd,globStart,globEnd,1,0,1,1);
+ MCAuto<DataArrayInt> famFieldCpy(famField->deepCopy());
+ ret->setFamilyFieldArr(*lev,famFieldCpy);
}
- globStart=globEnd;
- }
- newm1->setCoords(getCoords());
- setMeshAtLevel(-1,newm1);
- setFamilyFieldArr(-1,newFam);
- std::string grpName2(grpNameM1); grpName2+="_dup";
- addFamily(grpName2,idd);
- addFamilyOnGrp(grpName2,grpName2);
- //
- fam=_fam_coords;
- if(fam)
- {
- int newNbOfNodes=getCoords()->getNumberOfTuples();
- newFam=DataArrayInt::New(); newFam->alloc(newNbOfNodes,1);
- newFam->setPartOfValues1(fam,0,nbNodes,1,0,1,1,true);
- newFam->setPartOfValuesSimple1(0,nbNodes,newNbOfNodes,1,0,1,1);
- _fam_coords=newFam;
}
- nodesDuplicated=nodeIdsToDuplicate.retn();
- cellsModified=cellsToModifyConn0.retn();
- cellsNotModified=cellsToModifyConn1.retn();
+ return ret.retn();
}
/*!
- * \param [out] oldCode retrieves the distribution of types before the call if true is returned
- * \param [out] newCode etrieves the distribution of types after the call if true is returned
- * \param [out] o2nRenumCell tells for **all levels** the old 2 new renumbering of cells.
- *
- * \return false if no modification has been performed linked to the unpolyzation. Neither cell type, not cell numbers. When false is returned no need of field on cells or on gauss renumbering.
- * Inversely, if true is returned, it means that distribution of cell by geometric type has changed and field on cell and field on gauss point must be renumbered.
+ * Computes the symmetry of \a this.
+ * \return a new object.
*/
-bool MEDFileUMesh::unPolyze(std::vector<int>& oldCode, std::vector<int>& newCode, DataArrayInt *& o2nRenumCell)
+MCAuto<MEDFileUMesh> MEDFileUMesh::symmetry3DPlane(const double point[3], const double normalVector[3]) const
{
- o2nRenumCell=0; oldCode.clear(); newCode.clear();
- std::vector<int> levs=getNonEmptyLevels();
- bool ret=false;
- std::vector< const DataArrayInt* > renumCellsSplited;//same than memorySaverIfThrow
- std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > memorySaverIfThrow;//same than renumCellsSplited only in case of throw
- int start=0;
- int end=0;
- for(std::vector<int>::reverse_iterator it=levs.rbegin();it!=levs.rend();it++)
+ MCAuto<MEDFileUMesh> ret(deepCopy());
+ DataArrayDouble *myCoo(getCoords());
+ if(myCoo)
{
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingUMesh> m=getMeshAtLevel(*it);
- std::vector<int> code1=m->getDistributionOfTypes();
- end=PutInThirdComponentOfCodeOffset(code1,start);
- oldCode.insert(oldCode.end(),code1.begin(),code1.end());
- bool hasChanged=m->unPolyze();
- DataArrayInt *fake=0;
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> o2nCellsPart=m->getLevArrPerCellTypes(MEDCouplingUMesh::MEDMEM_ORDER,
- MEDCouplingUMesh::MEDMEM_ORDER+MEDCouplingUMesh::N_MEDMEM_ORDER,fake);
- fake->decrRef();
- renumCellsSplited.push_back(o2nCellsPart); memorySaverIfThrow.push_back(o2nCellsPart);
- if(hasChanged)
+ MCAuto<DataArrayDouble> newCoo(myCoo->symmetry3DPlane(point,normalVector));
+ ret->setCoordsForced(newCoo);
+ }
+ return ret;
+}
+
+MCAuto<MEDFileUMesh> MEDFileUMesh::Aggregate(const std::vector<const MEDFileUMesh *>& meshes)
+{
+ if(meshes.empty())
+ throw INTERP_KERNEL::Exception("MEDFileUMesh::Aggregate : empty input vector !");
+ std::size_t sz(meshes.size()),i(0);
+ std::vector<const DataArrayDouble *> coos(sz);
+ std::vector<const DataArrayInt *> fam_coos(sz),num_coos(sz);
+ for(std::vector<const MEDFileUMesh *>::const_iterator it=meshes.begin();it!=meshes.end();it++,i++)
+ {
+ if(!(*it))
+ throw INTERP_KERNEL::Exception("MEDFileUMesh::Aggregate : presence of NULL pointer in input vector !");
+ coos[i]=(*it)->getCoords();
+ fam_coos[i]=(*it)->getFamilyFieldAtLevel(1);
+ num_coos[i]=(*it)->getNumberFieldAtLevel(1);
+ }
+ const MEDFileUMesh *ref(meshes[0]);
+ int spaceDim(ref->getSpaceDimension()),meshDim(ref->getMeshDimension());
+ std::vector<int> levs(ref->getNonEmptyLevels());
+ std::map<int, std::vector<const DataArrayInt *> > m_fam,m_renum;
+ std::map<int, std::vector< MCAuto< MEDCouplingUMesh > > > m_mesh2;
+ std::map<int, std::vector<const MEDCouplingUMesh *> > m_mesh;
+ std::map<std::string,int> map1;
+ std::map<std::string, std::vector<std::string> > map2;
+ for(std::vector<const MEDFileUMesh *>::const_iterator it=meshes.begin();it!=meshes.end();it++,i++)
+ {
+ if((*it)->getSpaceDimension()!=spaceDim)
+ throw INTERP_KERNEL::Exception("MEDFileUMesh::Aggregate : space dimension must be homogeneous !");
+ if((*it)->getMeshDimension()!=meshDim)
+ throw INTERP_KERNEL::Exception("MEDFileUMesh::Aggregate : mesh dimension must be homogeneous !");
+ if((*it)->getNonEmptyLevels()!=levs)
+ throw INTERP_KERNEL::Exception("MEDFileUMesh::Aggregate : levels must be the same for elements in input vector !");
+ for(std::vector<int>::const_iterator it2=levs.begin();it2!=levs.end();it2++)
{
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> o2nCellsPart2=o2nCellsPart->buildPermArrPerLevel();
- m->renumberCells(o2nCellsPart2->getConstPointer(),false);
- ret=true;
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> famField2,numField2;
- const DataArrayInt *famField=getFamilyFieldAtLevel(*it); if(famField) { famField->incrRef(); famField2=const_cast<DataArrayInt *>(famField); }
- const DataArrayInt *numField=getNumberFieldAtLevel(*it); if(numField) { numField->incrRef(); numField2=const_cast<DataArrayInt *>(numField); }
- setMeshAtLevel(*it,m);
- std::vector<int> code2=m->getDistributionOfTypes();
- end=PutInThirdComponentOfCodeOffset(code2,start);
- newCode.insert(newCode.end(),code2.begin(),code2.end());
- //
- if(o2nCellsPart2->isIdentity())
- continue;
- if(famField)
- {
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> newFamField=famField->renumber(o2nCellsPart2->getConstPointer());
- setFamilyFieldArr(*it,newFamField);
- }
- if(numField)
+ MCAuto<MEDCouplingUMesh> locMesh((*it)->getMeshAtLevel(*it2));
+ m_mesh[*it2].push_back(locMesh); m_mesh2[*it2].push_back(locMesh);
+ m_fam[*it2].push_back((*it)->getFamilyFieldAtLevel(*it2));
+ m_renum[*it2].push_back((*it)->getNumberFieldAtLevel(*it2));
+ }
+ const std::map<std::string,int>& locMap1((*it)->getFamilyInfo());
+ for(std::map<std::string,int>::const_iterator it3=locMap1.begin();it3!=locMap1.end();it3++)
+ map1[(*it3).first]=(*it3).second;
+ const std::map<std::string, std::vector<std::string> >& locMap2((*it)->getGroupInfo());
+ for(std::map<std::string, std::vector<std::string> >::const_iterator it4=locMap2.begin();it4!=locMap2.end();it4++)
+ map2[(*it4).first]=(*it4).second;
+ }
+ // Easy part : nodes
+ MCAuto<MEDFileUMesh> ret(MEDFileUMesh::New());
+ MCAuto<DataArrayDouble> coo(DataArrayDouble::Aggregate(coos));
+ ret->setCoords(coo);
+ if(std::find(fam_coos.begin(),fam_coos.end(),(const DataArrayInt *)0)==fam_coos.end())
+ {
+ MCAuto<DataArrayInt> fam_coo(DataArrayInt::Aggregate(fam_coos));
+ ret->setFamilyFieldArr(1,fam_coo);
+ }
+ if(std::find(num_coos.begin(),num_coos.end(),(const DataArrayInt *)0)==num_coos.end())
+ {
+ MCAuto<DataArrayInt> num_coo(DataArrayInt::Aggregate(num_coos));
+ ret->setRenumFieldArr(1,num_coo);
+ }
+ // cells
+ for(std::vector<int>::const_iterator it=levs.begin();it!=levs.end();it++)
+ {
+ std::map<int, std::vector<const MEDCouplingUMesh *> >::const_iterator it2(m_mesh.find(*it));
+ if(it2==m_mesh.end())
+ throw INTERP_KERNEL::Exception("MEDFileUMesh::Aggregate : internal error 1 !");
+ MCAuto<MEDCouplingUMesh> mesh(MEDCouplingUMesh::MergeUMeshes((*it2).second));
+ mesh->setCoords(coo); mesh->setName(ref->getName());
+ MCAuto<DataArrayInt> renum(mesh->sortCellsInMEDFileFrmt());
+ ret->setMeshAtLevel(*it,mesh);
+ std::map<int, std::vector<const DataArrayInt *> >::const_iterator it3(m_fam.find(*it)),it4(m_renum.find(*it));
+ if(it3!=m_fam.end())
+ {
+ const std::vector<const DataArrayInt *>& fams((*it3).second);
+ if(std::find(fams.begin(),fams.end(),(const DataArrayInt *)0)==fams.end())
{
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> newNumField=numField->renumber(o2nCellsPart2->getConstPointer());
- setRenumFieldArr(*it,newNumField);
+ MCAuto<DataArrayInt> famm(DataArrayInt::Aggregate(fams));
+ famm->renumberInPlace(renum->begin());
+ ret->setFamilyFieldArr(*it,famm);
}
}
- else
+ if(it4!=m_renum.end())
{
- newCode.insert(newCode.end(),code1.begin(),code1.end());
+ const std::vector<const DataArrayInt *>& renums((*it4).second);
+ if(std::find(renums.begin(),renums.end(),(const DataArrayInt *)0)==renums.end())
+ {
+ MCAuto<DataArrayInt> renumm(DataArrayInt::Aggregate(renums));
+ renumm->renumberInPlace(renum->begin());
+ ret->setRenumFieldArr(*it,renumm);
+ }
}
- start=end;
- }
- if(ret)
- {
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> renumCells=DataArrayInt::Aggregate(renumCellsSplited);
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> o2nRenumCellRet=renumCells->buildPermArrPerLevel();
- o2nRenumCell=o2nRenumCellRet.retn();
}
+ //
+ ret->setFamilyInfo(map1);
+ ret->setGroupInfo(map2);
+ ret->setName(ref->getName());
return ret;
}
-struct MEDLoaderAccVisit1
+MEDCouplingMappedExtrudedMesh *MEDFileUMesh::convertToExtrudedMesh() const
{
- MEDLoaderAccVisit1():_new_nb_of_nodes(0) { }
- int operator()(bool val) { return val?_new_nb_of_nodes++:-1; }
- int _new_nb_of_nodes;
-};
+ if(getMeshDimension()!=3)
+ throw INTERP_KERNEL::Exception("MEDFileUMesh::convertToExtrudedMesh : works only for 3D mesh !");
+ MCAuto<MEDCouplingUMesh> m3D(getMeshAtLevel(0)),m2D(getMeshAtLevel(-1));
+ if(m3D.isNull() || m2D.isNull())
+ throw INTERP_KERNEL::Exception("MEDFileUMesh::convertToExtrudedMesh : this must be defined both at level 0 and level -1 !");
+ int zeId(getFamilyId(GetSpeStr4ExtMesh()));
+ MCAuto<MEDCouplingMappedExtrudedMesh> ret(MEDCouplingMappedExtrudedMesh::New(m3D,m2D,zeId));
+ return ret.retn();
+}
-/*!
- * Array returned is the correspondance in \b old \b to \b new format. The returned array is newly created and should be dealt by the caller.
- * The maximum value stored in returned array is the number of nodes of \a this minus 1 after call of this method.
- * The size of returned array is the number of nodes of the old (previous to the call of this method) number of nodes.
- * -1 values in returned array means that the corresponding old node is no more used.
- *
- * \return newly allocated array containing correspondance in \b old \b to \b new format. If all nodes in \a this are fetched \c NULL pointer is returned and nothing
- * is modified in \a this.
- * \throw If no coordinates are set in \a this or if there is in any available mesh in \a this a cell having a nodal connectivity containing a node id not in the range of
- * set coordinates.
- */
-DataArrayInt *MEDFileUMesh::zipCoords()
+void MEDFileUMesh::serialize(std::vector<double>& tinyDouble, std::vector<int>& tinyInt, std::vector<std::string>& tinyStr, std::vector< MCAuto<DataArrayInt> >& bigArraysI, MCAuto<DataArrayDouble>& bigArrayD)
{
- const DataArrayDouble *coo=getCoords();
- if(!coo)
- throw INTERP_KERNEL::Exception("MEDFileUMesh::zipCoords : no coordinates set in this !");
- int nbOfNodes=coo->getNumberOfTuples();
- std::vector<bool> nodeIdsInUse(nbOfNodes,false);
- std::vector<int> neLevs=getNonEmptyLevels();
- for(std::vector<int>::const_iterator lev=neLevs.begin();lev!=neLevs.end();lev++)
+ clearNonDiscrAttributes();
+ forceComputationOfParts();
+ tinyDouble.clear(); tinyInt.clear(); tinyStr.clear(); bigArraysI.clear(); bigArrayD=0;
+ std::vector<int> layer0;
+ layer0.push_back(getAxisType());//0 i
+ layer0.push_back(_order); //1 i
+ layer0.push_back(_iteration);//2 i
+ layer0.push_back(getSpaceDimension());//3 i
+ tinyDouble.push_back(_time);//0 d
+ tinyStr.push_back(_name);//0 s
+ tinyStr.push_back(_desc_name);//1 s
+ for(int i=0;i<getSpaceDimension();i++)
+ tinyStr.push_back(_coords->getInfoOnComponent(i));
+ layer0.push_back((int)_families.size());//4 i <- key info aa layer#0
+ for(std::map<std::string,int>::const_iterator it=_families.begin();it!=_families.end();it++)
{
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingUMesh> m=getMeshAtLevel(*lev);
- m->computeNodeIdsAlg(nodeIdsInUse);
+ tinyStr.push_back((*it).first);
+ layer0.push_back((*it).second);
}
- int nbrOfNodesInUse=(int)std::count(nodeIdsInUse.begin(),nodeIdsInUse.end(),true);
- if(nbrOfNodesInUse==nbOfNodes)
- return 0;
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbOfNodes,1);
- std::transform(nodeIdsInUse.begin(),nodeIdsInUse.end(),ret->getPointer(),MEDLoaderAccVisit1());
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret2=ret->invertArrayO2N2N2OBis(nbrOfNodesInUse);
- MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> newCoords=coo->selectByTupleIdSafe(ret2->begin(),ret2->end());
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> newFamCoords;
- MEDCouplingAutoRefCountObjectPtr<DataArrayAsciiChar> newNameCoords;
- if((const DataArrayInt *)_fam_coords)
- newFamCoords=_fam_coords->selectByTupleIdSafe(ret2->begin(),ret2->end());
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> newNumCoords;
- if((const DataArrayInt *)_num_coords)
- newNumCoords=_num_coords->selectByTupleIdSafe(ret2->begin(),ret2->end());
- if((const DataArrayAsciiChar *)_name_coords)
- newNameCoords=static_cast<DataArrayAsciiChar *>(_name_coords->selectByTupleIdSafe(ret2->begin(),ret2->end()));
- _coords=newCoords; _fam_coords=newFamCoords; _num_coords=newNumCoords; _name_coords=newNameCoords; _rev_num_coords=0;
- for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileUMeshSplitL1> >::iterator it=_ms.begin();it!=_ms.end();it++)
+ layer0.push_back((int)_groups.size());//4+aa i <- key info bb layer#0
+ for(std::map<std::string, std::vector<std::string> >::const_iterator it0=_groups.begin();it0!=_groups.end();it0++)
{
- if((MEDFileUMeshSplitL1*)*it)
- (*it)->renumberNodesInConn(ret->begin());
+ layer0.push_back((int)(*it0).second.size());
+ tinyStr.push_back((*it0).first);
+ for(std::vector<std::string>::const_iterator it1=((*it0).second).begin();it1!=((*it0).second).end();it1++)
+ tinyStr.push_back(*it1);
+ }
+ // sizeof(layer0)==4+aa+1+bb layer#0
+ bigArrayD=_coords;// 0 bd
+ bigArraysI.push_back(_fam_coords);// 0 bi
+ bigArraysI.push_back(_num_coords);// 1 bi
+ const PartDefinition *pd(_part_coords);
+ if(!pd)
+ layer0.push_back(-1);
+ else
+ {
+ std::vector<int> tmp0;
+ pd->serialize(tmp0,bigArraysI);
+ tinyInt.push_back(tmp0.size());
+ tinyInt.insert(tinyInt.end(),tmp0.begin(),tmp0.end());
+ }
+ //
+ std::vector<int> layer1;
+ std::vector<int> levs(getNonEmptyLevels());
+ layer1.push_back((int)levs.size());// 0 i <- key
+ layer1.insert(layer1.end(),levs.begin(),levs.end());
+ for(std::vector<int>::const_iterator it=levs.begin();it!=levs.end();it++)
+ {
+ const MEDFileUMeshSplitL1 *lev(getMeshAtLevSafe(*it));
+ lev->serialize(layer1,bigArraysI);
+ }
+ // put layers all together.
+ tinyInt.push_back(layer0.size());
+ tinyInt.insert(tinyInt.end(),layer0.begin(),layer0.end());
+ tinyInt.push_back(layer1.size());
+ tinyInt.insert(tinyInt.end(),layer1.begin(),layer1.end());
+}
+
+void MEDFileUMesh::unserialize(std::vector<double>& tinyDouble, std::vector<int>& tinyInt, std::vector<std::string>& tinyStr,
+ std::vector< MCAuto<DataArrayInt> >& bigArraysI, MCAuto<DataArrayDouble>& bigArrayD)
+{
+ int sz0(tinyInt[0]);
+ std::vector<int> layer0(tinyInt.begin()+1,tinyInt.begin()+1+sz0);
+ int sz1(tinyInt[sz0+1]);
+ std::vector<int> layer1(tinyInt.begin()+2+sz0,tinyInt.begin()+2+sz0+sz1);
+ //
+ std::reverse(layer0.begin(),layer0.end());
+ std::reverse(layer1.begin(),layer1.end());
+ std::reverse(tinyDouble.begin(),tinyDouble.end());
+ std::reverse(tinyStr.begin(),tinyStr.end());
+ std::reverse(bigArraysI.begin(),bigArraysI.end());
+ //
+ setAxisType((MEDCouplingAxisType)layer0.back()); layer0.pop_back();
+ _order=layer0.back(); layer0.pop_back();
+ _iteration=layer0.back(); layer0.pop_back();
+ int spaceDim(layer0.back()); layer0.pop_back();
+ _time=tinyDouble.back(); tinyDouble.pop_back();
+ _name=tinyStr.back(); tinyStr.pop_back();
+ _desc_name=tinyStr.back(); tinyStr.pop_back();
+ _coords=bigArrayD; _coords->rearrange(spaceDim);
+ for(int i=0;i<spaceDim;i++)
+ {
+ _coords->setInfoOnComponent(i,tinyStr.back());
+ tinyStr.pop_back();
+ }
+ int nbOfFams(layer0.back()); layer0.pop_back();
+ _families.clear();
+ for(int i=0;i<nbOfFams;i++)
+ {
+ _families[tinyStr.back()]=layer0.back();
+ tinyStr.pop_back(); layer0.pop_back();
+ }
+ int nbGroups(layer0.back()); layer0.pop_back();
+ _groups.clear();
+ for(int i=0;i<nbGroups;i++)
+ {
+ std::string grpName(tinyStr.back()); tinyStr.pop_back();
+ int nbOfFamsOnGrp(layer0.back()); layer0.pop_back();
+ std::vector<std::string> fams(nbOfFamsOnGrp);
+ for(int j=0;j<nbOfFamsOnGrp;j++)
+ {
+ fams[j]=tinyStr.back(); tinyStr.pop_back();
+ }
+ _groups[grpName]=fams;
+ }
+ _fam_coords=bigArraysI.back(); bigArraysI.pop_back();
+ _num_coords=bigArraysI.back(); bigArraysI.pop_back();
+ _part_coords=0;
+ int isPd(layer0.back()); layer0.pop_back();
+ if(isPd!=-1)
+ {
+ std::vector<int> tmp0(layer0.begin(),layer0.begin()+isPd);
+ layer0.erase(layer0.begin(),layer0.begin()+isPd);
+ _part_coords=PartDefinition::Unserialize(tmp0,bigArraysI);
+ }
+ if(!layer0.empty())
+ throw INTERP_KERNEL::Exception("MEDFileUMesh::unserialize : something wrong during unserialization #1 !");
+ //
+ int nbLevs(layer1.back()); layer1.pop_back();
+ std::vector<int> levs(layer1.rbegin(),layer1.rbegin()+nbLevs); layer1.erase(layer1.end()-nbLevs,layer1.end());
+ _ms.clear();
+ int maxLev(-(*std::min_element(levs.begin(),levs.end())));
+ _ms.resize(maxLev+1);
+ for(int i=0;i<nbLevs;i++)
+ {
+ int lev(levs[i]);
+ int pos(-lev);
+ _ms[pos]=MEDFileUMeshSplitL1::Unserialize(_name,_coords,layer1,bigArraysI);
}
- return ret.retn();
}
/*!
* Adds a group of nodes to \a this mesh.
* \param [in] ids - a DataArrayInt providing ids and a name of the group to add.
* The ids should be sorted and different each other (MED file norm).
+ *
+ * \warning this method can alter default "FAMILLE_ZERO" family.
+ * For users sensitive to this a call to MEDFileMesh::rearrangeFamilies will be necessary after addGroup session.
+ *
* \throw If the node coordinates array is not set.
* \throw If \a ids == \c NULL.
* \throw If \a ids->getName() == "".
*/
void MEDFileUMesh::addNodeGroup(const DataArrayInt *ids)
{
- const DataArrayDouble *coords=_coords;
+ const DataArrayDouble *coords(_coords);
if(!coords)
throw INTERP_KERNEL::Exception("MEDFileUMesh::addNodeGroup : no coords set !");
- int nbOfNodes=coords->getNumberOfTuples();
+ int nbOfNodes(coords->getNumberOfTuples());
if(!((DataArrayInt *)_fam_coords))
{ _fam_coords=DataArrayInt::New(); _fam_coords->alloc(nbOfNodes,1); _fam_coords->fillWithZero(); }
//
/*!
* Adds a group of nodes/cells/faces/edges to \a this mesh.
+ *
* \param [in] ids - a DataArrayInt providing ids and a name of the group to add.
* The ids should be sorted and different each other (MED file norm).
+ *
+ * \warning this method can alter default "FAMILLE_ZERO" family.
+ * For users sensitive to this a call to MEDFileMesh::rearrangeFamilies will be necessary after addGroup session.
+ *
* \throw If the node coordinates array is not set.
* \throw If \a ids == \c NULL.
* \throw If \a ids->getName() == "".
*/
void MEDFileUMesh::addGroup(int meshDimRelToMaxExt, const DataArrayInt *ids)
{
- std::vector<int> levs=getNonEmptyLevelsExt();
+ std::vector<int> levs(getNonEmptyLevelsExt());
if(std::find(levs.begin(),levs.end(),meshDimRelToMaxExt)==levs.end())
{
std::ostringstream oss; oss << "MEDFileUMesh::addGroup : level " << meshDimRelToMaxExt << " not available ! Should be in ";
}
if(meshDimRelToMaxExt==1)
{ addNodeGroup(ids); return ; }
- MEDFileUMeshSplitL1 *lev=getMeshAtLevSafe(meshDimRelToMaxExt);
- DataArrayInt *fam=lev->getOrCreateAndGetFamilyField();
+ MEDFileUMeshSplitL1 *lev(getMeshAtLevSafe(meshDimRelToMaxExt));
+ DataArrayInt *fam(lev->getOrCreateAndGetFamilyField());
addGroupUnderground(false,ids,fam);
}
-/*!
- * \param [in] ids ids and group name of the new group to add. The ids should be sorted and different each other (MED file norm).
- * \parma [in,out] famArr family array on level of interest to be renumbered. The input pointer should be not \c NULL (no check of that will be performed)
- */
-void MEDFileUMesh::addGroupUnderground(bool isNodeGroup, const DataArrayInt *ids, DataArrayInt *famArr)
-{
- if(!ids)
- throw INTERP_KERNEL::Exception("MEDFileUMesh::addGroup : NULL pointer in input !");
- std::string grpName(ids->getName());
- if(grpName.empty())
- throw INTERP_KERNEL::Exception("MEDFileUMesh::addGroup : empty group name ! MED file format do not accept empty group name !");
- ids->checkStrictlyMonotonic(true);
- famArr->incrRef(); MEDCouplingAutoRefCountObjectPtr<DataArrayInt> famArrTmp(famArr);
- std::vector<std::string> grpsNames=getGroupsNames();
- if(std::find(grpsNames.begin(),grpsNames.end(),grpName)!=grpsNames.end())
- {
- std::ostringstream oss; oss << "MEDFileUMesh::addGroup : Group with name \"" << grpName << "\" already exists ! Destroy it before calling this method !";
- throw INTERP_KERNEL::Exception(oss.str().c_str());
- }
- std::list< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > allFamIds=getAllNonNullFamilyIds();
- allFamIds.erase(std::find(allFamIds.begin(),allFamIds.end(),famArrTmp));
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> famIds=famArr->selectByTupleIdSafe(ids->begin(),ids->end());
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> diffFamIds=famIds->getDifferentValues();
- std::vector<int> familyIds;
- std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > idsPerfamiliyIds;
- int maxVal=getTheMaxAbsFamilyId()+1;
- std::map<std::string,int> families(_families);
- std::map<std::string, std::vector<std::string> > groups(_groups);
- std::vector<std::string> fams;
- bool created(false);
- for(const int *famId=diffFamIds->begin();famId!=diffFamIds->end();famId++)
- {
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ids2Tmp=famIds->getIdsEqual(*famId);
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ids2=ids->selectByTupleId(ids2Tmp->begin(),ids2Tmp->end());
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ids1=famArr->getIdsEqual(*famId);
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret0(ids1->buildSubstractionOptimized(ids2));
- if(ret0->empty())
- {
- bool isFamPresent=false;
- for(std::list< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> >::const_iterator itl=allFamIds.begin();itl!=allFamIds.end() && !isFamPresent;itl++)
- isFamPresent=(*itl)->presenceOfValue(*famId);
- if(!isFamPresent)
- { familyIds.push_back(*famId); idsPerfamiliyIds.push_back(ret0); fams.push_back(FindOrCreateAndGiveFamilyWithId(families,*famId,created)); } // adding *famId in grp
- else
- {
- familyIds.push_back(isNodeGroup?maxVal:-maxVal); idsPerfamiliyIds.push_back(ids2);
- std::string locFamName=FindOrCreateAndGiveFamilyWithId(families,isNodeGroup?maxVal:-maxVal,created);
- fams.push_back(locFamName);
- if(existsFamily(*famId))
- {
- std::string locFamName2=getFamilyNameGivenId(*famId); std::vector<std::string> v(2); v[0]=locFamName2; v[1]=locFamName;
- ChangeAllGroupsContainingFamily(groups,getFamilyNameGivenId(*famId),v);
- }
- maxVal++;
- } // modifying all other groups on *famId to lie on maxVal and lie the grp on maxVal
- }
- else
- {
- familyIds.push_back(isNodeGroup?maxVal:-maxVal); idsPerfamiliyIds.push_back(ret0); // modifying all other groups on *famId to lie on maxVal and on maxVal+1
- familyIds.push_back(isNodeGroup?maxVal+1:-maxVal-1); idsPerfamiliyIds.push_back(ids2);//grp lie only on maxVal+1
- std::string n2(FindOrCreateAndGiveFamilyWithId(families,isNodeGroup?maxVal+1:-maxVal-1,created)); fams.push_back(n2);
- if(existsFamily(*famId))
- {
- std::string n1(FindOrCreateAndGiveFamilyWithId(families,isNodeGroup?maxVal:-maxVal,created)); std::vector<std::string> v(2); v[0]=n1; v[1]=n2;
- ChangeAllGroupsContainingFamily(groups,getFamilyNameGivenId(*famId),v);
- }
- maxVal+=2;
- }
- }
- for(std::size_t i=0;i<familyIds.size();i++)
- {
- DataArrayInt *da=idsPerfamiliyIds[i];
- famArr->setPartOfValuesSimple3(familyIds[i],da->begin(),da->end(),0,1,1);
- }
- _families=families;
- _groups=groups;
- _groups[grpName]=fams;
-}
-
/*!
* Changes a name of a family specified by its id.
* \param [in] id - the id of the family of interest.
*/
void MEDFileUMesh::setMeshAtLevel(int meshDimRelToMax, MEDCoupling1GTUMesh *m)
{
- MEDCouplingAutoRefCountObjectPtr<MEDFileUMeshSplitL1> elt(new MEDFileUMeshSplitL1(m));
+ MCAuto<MEDFileUMeshSplitL1> elt(new MEDFileUMeshSplitL1(m));
checkAndGiveEntryInSplitL1(meshDimRelToMax,m)=elt;
}
*/
void MEDFileUMesh::setMeshAtLevel(int meshDimRelToMax, MEDCouplingUMesh *m, bool newOrOld)
{
- MEDCouplingAutoRefCountObjectPtr<MEDFileUMeshSplitL1> elt(new MEDFileUMeshSplitL1(m,newOrOld));
+ MCAuto<MEDFileUMeshSplitL1> elt(new MEDFileUMeshSplitL1(m,newOrOld));
checkAndGiveEntryInSplitL1(meshDimRelToMax,m)=elt;
}
-MEDCouplingAutoRefCountObjectPtr<MEDFileUMeshSplitL1>& MEDFileUMesh::checkAndGiveEntryInSplitL1(int meshDimRelToMax, MEDCouplingPointSet *m)
+MCAuto<MEDFileUMeshSplitL1>& MEDFileUMesh::checkAndGiveEntryInSplitL1(int meshDimRelToMax, MEDCouplingPointSet *m)
{
dealWithTinyInfo(m);
std::vector<int> levSet=getNonEmptyLevels();
* \throw If the meshes in \a ms do not share the same node coordinates array.
* \throw If the node coordinates array of \a this mesh (if any) is not the same as that
* of the given meshes.
- * \throw If \a ms[ i ] is not well defined (MEDCouplingUMesh::checkCoherency()).
+ * \throw If \a ms[ i ] is not well defined (MEDCouplingUMesh::checkConsistencyLight()).
* \throw If names of some meshes in \a ms are equal.
* \throw If \a ms includes a mesh with an empty name.
*/
if((DataArrayDouble *)_coords!=coo)
throw INTERP_KERNEL::Exception("MEDFileUMesh::setGroupsFromScratch : coordinates mismatches !");
std::vector<DataArrayInt *> corr;
- MEDCouplingAutoRefCountObjectPtr<MEDCouplingUMesh> m=MEDCouplingUMesh::FuseUMeshesOnSameCoords(ms,_zipconn_pol,corr);
- std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > corr3(corr.begin(),corr.end());
+ MCAuto<MEDCouplingUMesh> m=MEDCouplingUMesh::FuseUMeshesOnSameCoords(ms,_zipconn_pol,corr);
+ std::vector< MCAuto<DataArrayInt> > corr3(corr.begin(),corr.end());
setMeshAtLevel(meshDimRelToMax,m,renum);
std::vector<const DataArrayInt *> corr2(corr.begin(),corr.end());
setGroupsAtLevel(meshDimRelToMax,corr2,true);
* \throw If the meshes in \a ms do not share the same node coordinates array.
* \throw If the node coordinates array of \a this mesh (if any) is not the same as that
* of the given meshes.
- * \throw If \a ms[ i ] is not well defined (MEDCouplingUMesh::checkCoherency()).
+ * \throw If \a ms[ i ] is not well defined (MEDCouplingUMesh::checkConsistencyLight()).
* \throw If names of some meshes in \a ms are equal.
* \throw If \a ms includes a mesh with an empty name.
*/
if((DataArrayDouble *)_coords!=coo)
throw INTERP_KERNEL::Exception("MEDFileUMesh::setGroupsOnSetMesh : coordinates mismatches !");
MEDCouplingUMesh *m=getMeshAtLevel(meshDimRelToMax,renum);
- std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > corr(ms.size());
+ std::vector< MCAuto<DataArrayInt> > corr(ms.size());
int i=0;
for(std::vector<const MEDCouplingUMesh *>::const_iterator it=ms.begin();it!=ms.end();it++,i++)
{
int mdim=ms[0]->getMeshDimension();
for(unsigned int i=1;i<ms.size();i++)
{
- ms[i]->checkCoherency();
+ ms[i]->checkConsistencyLight();
if(ms[i]->getCoords()!=ret)
throw INTERP_KERNEL::Exception("MEDFileUMesh::checkMultiMesh : meshes must share the same coords !");
if(ms[i]->getMeshDimension()!=mdim)
throw INTERP_KERNEL::Exception("MEDFileUMesh::setFamilyFieldArr : Dimension request is invalid (>1) !");
int traducedRk=-meshDimRelToMaxExt;
if(traducedRk>=(int)_ms.size())
- throw INTERP_KERNEL::Exception("Invalid mesh dim relative to max given ! To low !");
+ throw INTERP_KERNEL::Exception("Invalid mesh dim relative to max given ! Too low !");
if((MEDFileUMeshSplitL1 *)_ms[traducedRk]==0)
throw INTERP_KERNEL::Exception("On specified lev (or entity) no cells exists !");
return _ms[traducedRk]->setFamilyArr(famArr);
throw INTERP_KERNEL::Exception("MEDFileUMesh::setRenumArr : Dimension request is invalid (>1) !");
int traducedRk=-meshDimRelToMaxExt;
if(traducedRk>=(int)_ms.size())
- throw INTERP_KERNEL::Exception("Invalid mesh dim relative to max given ! To low !");
+ throw INTERP_KERNEL::Exception("Invalid mesh dim relative to max given ! Too low !");
if((MEDFileUMeshSplitL1 *)_ms[traducedRk]==0)
throw INTERP_KERNEL::Exception("On specified lev (or entity) no cells exists !");
return _ms[traducedRk]->setRenumArr(renumArr);
throw INTERP_KERNEL::Exception("MEDFileUMesh::setNameFieldAtLevel : Dimension request is invalid (>1) !");
int traducedRk=-meshDimRelToMaxExt;
if(traducedRk>=(int)_ms.size())
- throw INTERP_KERNEL::Exception("Invalid mesh dim relative to max given ! To low !");
+ throw INTERP_KERNEL::Exception("Invalid mesh dim relative to max given ! Too low !");
if((MEDFileUMeshSplitL1 *)_ms[traducedRk]==0)
throw INTERP_KERNEL::Exception("On specified lev (or entity) no cells exists !");
return _ms[traducedRk]->setNameArr(nameArr);
void MEDFileUMesh::synchronizeTinyInfoOnLeaves() const
{
- for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();it!=_ms.end();it++)
+ for(std::vector< MCAuto<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();it!=_ms.end();it++)
if((const MEDFileUMeshSplitL1 *)(*it))
(*it)->synchronizeTinyInfo(*this);
}
DataArrayInt *arr=_fam_coords;
if(arr)
arr->changeValue(oldId,newId);
- for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileUMeshSplitL1> >::iterator it=_ms.begin();it!=_ms.end();it++)
+ for(std::vector< MCAuto<MEDFileUMeshSplitL1> >::iterator it=_ms.begin();it!=_ms.end();it++)
{
MEDFileUMeshSplitL1 *sp=(*it);
if(sp)
}
}
-std::list< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > MEDFileUMesh::getAllNonNullFamilyIds() const
+std::list< MCAuto<DataArrayInt> > MEDFileUMesh::getAllNonNullFamilyIds() const
{
- std::list< MEDCouplingAutoRefCountObjectPtr<DataArrayInt> > ret;
+ std::list< MCAuto<DataArrayInt> > ret;
const DataArrayInt *da(_fam_coords);
if(da)
- { da->incrRef(); ret.push_back(MEDCouplingAutoRefCountObjectPtr<DataArrayInt>(const_cast<DataArrayInt *>(da))); }
- for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();it!=_ms.end();it++)
+ { da->incrRef(); ret.push_back(MCAuto<DataArrayInt>(const_cast<DataArrayInt *>(da))); }
+ for(std::vector< MCAuto<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();it!=_ms.end();it++)
{
const MEDFileUMeshSplitL1 *elt(*it);
if(elt)
{
da=elt->getFamilyField();
if(da)
- { da->incrRef(); ret.push_back(MEDCouplingAutoRefCountObjectPtr<DataArrayInt>(const_cast<DataArrayInt *>(da))); }
+ { da->incrRef(); ret.push_back(MCAuto<DataArrayInt>(const_cast<DataArrayInt *>(da))); }
}
}
return ret;
return MEDFileMesh::getHeapMemorySizeWithoutChildren();
}
-std::vector<const BigMemoryObject *> MEDFileStructuredMesh::getDirectChildren() const
-{
- std::vector<const BigMemoryObject *> ret(MEDFileMesh::getDirectChildren());
- if((const DataArrayInt *)_fam_nodes)
- ret.push_back((const DataArrayInt *)_fam_nodes);
- if((const DataArrayInt *)_num_nodes)
- ret.push_back((const DataArrayInt *)_num_nodes);
- if((const DataArrayAsciiChar *)_names_nodes)
- ret.push_back((const DataArrayAsciiChar *)_names_nodes);
- if((const DataArrayInt *)_fam_cells)
- ret.push_back((const DataArrayInt *)_fam_cells);
- if((const DataArrayInt *)_num_cells)
- ret.push_back((const DataArrayInt *)_num_cells);
- if((const DataArrayAsciiChar *)_names_cells)
- ret.push_back((const DataArrayAsciiChar *)_names_cells);
- if((const DataArrayInt *)_fam_faces)
- ret.push_back((const DataArrayInt *)_fam_faces);
- if((const DataArrayInt *)_num_faces)
- ret.push_back((const DataArrayInt *)_num_faces);
- if((const DataArrayInt *)_rev_num_nodes)
- if((const DataArrayAsciiChar *)_names_faces)
- ret.push_back((const DataArrayAsciiChar *)_names_faces);
- ret.push_back((const DataArrayInt *)_rev_num_nodes);
- if((const DataArrayInt *)_rev_num_cells)
- ret.push_back((const DataArrayInt *)_rev_num_cells);
+std::vector<const BigMemoryObject *> MEDFileStructuredMesh::getDirectChildrenWithNull() const
+{
+ std::vector<const BigMemoryObject *> ret(MEDFileMesh::getDirectChildrenWithNull());
+ ret.push_back((const DataArrayInt *)_fam_nodes);
+ ret.push_back((const DataArrayInt *)_num_nodes);
+ ret.push_back((const DataArrayAsciiChar *)_names_nodes);
+ ret.push_back((const DataArrayInt *)_fam_cells);
+ ret.push_back((const DataArrayInt *)_num_cells);
+ ret.push_back((const DataArrayAsciiChar *)_names_cells);
+ ret.push_back((const DataArrayInt *)_fam_faces);
+ ret.push_back((const DataArrayInt *)_num_faces);
+ ret.push_back((const DataArrayInt *)_rev_num_nodes);
+ ret.push_back((const DataArrayAsciiChar *)_names_faces);
+ ret.push_back((const DataArrayInt *)_rev_num_cells);
+ ret.push_back((const MEDCoupling1SGTUMesh*)_faces_if_necessary);
return ret;
}
{
std::vector<int> famIds(getFamiliesIds(fams));
switch(meshDimRelToMaxExt)
- {
+ {
case 1:
{
if((const DataArrayInt *)_fam_nodes)
{
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da;
+ MCAuto<DataArrayInt> da;
if(!famIds.empty())
- da=_fam_nodes->getIdsEqualList(&famIds[0],&famIds[0]+famIds.size());
+ da=_fam_nodes->findIdsEqualList(&famIds[0],&famIds[0]+famIds.size());
else
- da=_fam_nodes->getIdsEqualList(0,0);
+ da=_fam_nodes->findIdsEqualList(0,0);
if(renum)
return MEDFileUMeshSplitL1::Renumber(_num_nodes,da);
else
{
if((const DataArrayInt *)_fam_cells)
{
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da;
+ MCAuto<DataArrayInt> da;
if(!famIds.empty())
- da=_fam_cells->getIdsEqualList(&famIds[0],&famIds[0]+famIds.size());
+ da=_fam_cells->findIdsEqualList(&famIds[0],&famIds[0]+famIds.size());
else
- da=_fam_cells->getIdsEqualList(0,0);
+ da=_fam_cells->findIdsEqualList(0,0);
if(renum)
return MEDFileUMeshSplitL1::Renumber(_num_cells,da);
else
{
if((const DataArrayInt *)_fam_faces)
{
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da;
+ MCAuto<DataArrayInt> da;
if(!famIds.empty())
- da=_fam_faces->getIdsEqualList(&famIds[0],&famIds[0]+famIds.size());
+ da=_fam_faces->findIdsEqualList(&famIds[0],&famIds[0]+famIds.size());
else
- da=_fam_faces->getIdsEqualList(0,0);
+ da=_fam_faces->findIdsEqualList(0,0);
if(renum)
return MEDFileUMeshSplitL1::Renumber(_num_faces,da);
else
}
default:
throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::getFamiliesArr : input meshDimRelative must be in [0,1,-1] !");
- }
+ }
+ throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::getFamiliesArr : unmanaged case !");
}
/*!
if(!mesh)
throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::setFamilyFieldArr : no structured mesh specified ! Impossible to set family array !");
switch(meshDimRelToMaxExt)
- {
+ {
case 0:
{
- int nbCells=mesh->getNumberOfCells();
- famArr->checkNbOfTuplesAndComp(nbCells,1,"MEDFileStructuredMesh::setFamilyFieldArr : Problem in size of Family arr ! Mismatch with number of cells of mesh !");
+ int nbCells(mesh->getNumberOfCells());
+ if(famArr)
+ famArr->checkNbOfTuplesAndComp(nbCells,1,"MEDFileStructuredMesh::setFamilyFieldArr : Problem in size of Family arr ! Mismatch with number of cells of mesh !");
_fam_cells=famArr;
break;
}
case 1:
{
- int nbNodes=mesh->getNumberOfNodes();
- famArr->checkNbOfTuplesAndComp(nbNodes,1,"MEDFileStructuredMesh::setFamilyFieldArr : Problem in size of Family arr ! Mismatch with number of nodes of mesh !");
+ int nbNodes(mesh->getNumberOfNodes());
+ if(famArr)
+ famArr->checkNbOfTuplesAndComp(nbNodes,1,"MEDFileStructuredMesh::setFamilyFieldArr : Problem in size of Family arr ! Mismatch with number of nodes of mesh !");
_fam_nodes=famArr;
break;
}
case -1:
{
- int nbCells=mesh->getNumberOfCellsOfSubLevelMesh();
- famArr->checkNbOfTuplesAndComp(nbCells,1,"MEDFileStructuredMesh::setFamilyFieldArr : Problem in size of Family arr ! Mismatch with number of faces of mesh !");
+ int nbCells(mesh->getNumberOfCellsOfSubLevelMesh());
+ if(famArr)
+ famArr->checkNbOfTuplesAndComp(nbCells,1,"MEDFileStructuredMesh::setFamilyFieldArr : Problem in size of Family arr ! Mismatch with number of faces of mesh !");
_fam_faces=famArr;
break;
}
default:
throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::setFamilyFieldArr : Only available for levels 0 or 1 or -1 !");
- }
+ }
if(famArr)
famArr->incrRef();
}
if(!mesh)
throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::setRenumFieldArr : no structured mesh specified ! Impossible to set number array !");
switch(meshDimRelToMaxExt)
- {
+ {
case 0:
{
int nbCells=mesh->getNumberOfCells();
}
default:
throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::setRenumFieldArr : Only available for levels 0 or 1 or -1 !");
- }
+ }
if(renumArr)
renumArr->incrRef();
}
if(!mesh)
throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::setNameFieldAtLevel : no structured mesh specified ! Impossible to set names array !");
switch(meshDimRelToMaxExt)
- {
+ {
case 0:
{
int nbCells=mesh->getNumberOfCells();
}
default:
throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::setNameFieldAtLevel : Only available for levels 0 or 1 or -1 !");
- }
+ }
if(nameArr)
nameArr->incrRef();
}
+/*!
+ * Adds a group of nodes to \a this mesh.
+ * \param [in] ids - a DataArrayInt providing ids and a name of the group to add.
+ * The ids should be sorted and different each other (MED file norm).
+ *
+ * \warning this method can alter default "FAMILLE_ZERO" family.
+ * For users sensitive to this a call to MEDFileMesh::rearrangeFamilies will be necessary after addGroup session.
+ *
+ * \throw If the node coordinates array is not set.
+ * \throw If \a ids == \c NULL.
+ * \throw If \a ids->getName() == "".
+ * \throw If \a ids does not respect the MED file norm.
+ * \throw If a group with name \a ids->getName() already exists.
+ */
+void MEDFileStructuredMesh::addNodeGroup(const DataArrayInt *ids)
+{
+ addGroup(1,ids);
+}
+
+/*!
+ * Adds a group of nodes/cells/faces/edges to \a this mesh.
+ *
+ * \param [in] ids - a DataArrayInt providing ids and a name of the group to add.
+ * The ids should be sorted and different each other (MED file norm).
+ *
+ * \warning this method can alter default "FAMILLE_ZERO" family.
+ * For users sensitive to this a call to MEDFileMesh::rearrangeFamilies will be necessary after addGroup session.
+ *
+ * \throw If the node coordinates array is not set.
+ * \throw If \a ids == \c NULL.
+ * \throw If \a ids->getName() == "".
+ * \throw If \a ids does not respect the MED file norm.
+ * \throw If a group with name \a ids->getName() already exists.
+ */
+void MEDFileStructuredMesh::addGroup(int meshDimRelToMaxExt, const DataArrayInt *ids)
+{
+ DataArrayInt *fam(getOrCreateAndGetFamilyFieldAtLevel(meshDimRelToMaxExt));
+ addGroupUnderground(false,ids,fam);
+ return ;
+}
+
/*!
* Returns the family field for mesh entities of a given dimension.
* \param [in] meshDimRelToMaxExt - the relative dimension of mesh entities.
const DataArrayInt *MEDFileStructuredMesh::getFamilyFieldAtLevel(int meshDimRelToMaxExt) const
{
switch(meshDimRelToMaxExt)
- {
+ {
case 0:
return _fam_cells;
case 1:
return _fam_faces;
default:
throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::getFamilyFieldAtLevel : Only available for levels 0 or 1 or -1 !");
- }
+ }
+}
+
+/*!
+ * Returns the family field for mesh entities of a given dimension.
+ * \param [in] meshDimRelToMaxExt - the relative dimension of mesh entities.
+ * \return const DataArrayInt * - the family field. It is an array of ids of families
+ * each mesh entity belongs to. It can be \c NULL.
+ * \throw If \a meshDimRelToMaxExt != 0 and \a meshDimRelToMaxExt != 1.
+ */
+DataArrayInt *MEDFileStructuredMesh::getFamilyFieldAtLevel(int meshDimRelToMaxExt)
+{
+ switch(meshDimRelToMaxExt)
+ {
+ case 0:
+ return _fam_cells;
+ case 1:
+ return _fam_nodes;
+ case -1:
+ return _fam_faces;
+ default:
+ throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::getFamilyFieldAtLevel : Only available for levels 0 or 1 or -1 !");
+ }
}
/*!
const DataArrayInt *MEDFileStructuredMesh::getNumberFieldAtLevel(int meshDimRelToMaxExt) const
{
switch(meshDimRelToMaxExt)
- {
+ {
case 0:
return _num_cells;
case 1:
return _num_faces;
default:
throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::getNumberFieldAtLevel : Only available for levels 0 or 1 or -1 !");
- }
+ }
}
/*!
const DataArrayAsciiChar *MEDFileStructuredMesh::getNameFieldAtLevel(int meshDimRelToMaxExt) const
{
switch(meshDimRelToMaxExt)
- {
+ {
case 0:
return _names_cells;
case 1:
return _names_faces;
default:
throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::getNameFieldAtLevel : Only available for levels 0 or 1 or -1 !");
- }
+ }
}
/*!
arr->changeValue(oldId,newId);
}
+std::list< MCAuto<DataArrayInt> > MEDFileStructuredMesh::getAllNonNullFamilyIds() const
+{
+ std::list< MCAuto<DataArrayInt> > ret;
+ const DataArrayInt *da(_fam_nodes);
+ if(da)
+ { da->incrRef(); ret.push_back(MCAuto<DataArrayInt>(const_cast<DataArrayInt *>(da))); }
+ da=_fam_cells;
+ if(da)
+ { da->incrRef(); ret.push_back(MCAuto<DataArrayInt>(const_cast<DataArrayInt *>(da))); }
+ da=_fam_faces;
+ if(da)
+ { da->incrRef(); ret.push_back(MCAuto<DataArrayInt>(const_cast<DataArrayInt *>(da))); }
+ return ret;
+}
+
void MEDFileStructuredMesh::deepCpyAttributes()
{
if((const DataArrayInt*)_fam_nodes)
- _fam_nodes=_fam_nodes->deepCpy();
+ _fam_nodes=_fam_nodes->deepCopy();
if((const DataArrayInt*)_num_nodes)
- _num_nodes=_num_nodes->deepCpy();
+ _num_nodes=_num_nodes->deepCopy();
if((const DataArrayAsciiChar*)_names_nodes)
- _names_nodes=_names_nodes->deepCpy();
+ _names_nodes=_names_nodes->deepCopy();
if((const DataArrayInt*)_fam_cells)
- _fam_cells=_fam_cells->deepCpy();
+ _fam_cells=_fam_cells->deepCopy();
if((const DataArrayInt*)_num_cells)
- _num_cells=_num_cells->deepCpy();
+ _num_cells=_num_cells->deepCopy();
if((const DataArrayAsciiChar*)_names_cells)
- _names_cells=_names_cells->deepCpy();
+ _names_cells=_names_cells->deepCopy();
if((const DataArrayInt*)_fam_faces)
- _fam_faces=_fam_faces->deepCpy();
+ _fam_faces=_fam_faces->deepCopy();
if((const DataArrayInt*)_num_faces)
- _num_faces=_num_faces->deepCpy();
+ _num_faces=_num_faces->deepCopy();
if((const DataArrayAsciiChar*)_names_faces)
- _names_faces=_names_faces->deepCpy();
+ _names_faces=_names_faces->deepCopy();
if((const DataArrayInt*)_rev_num_nodes)
- _rev_num_nodes=_rev_num_nodes->deepCpy();
+ _rev_num_nodes=_rev_num_nodes->deepCopy();
if((const DataArrayInt*)_rev_num_cells)
- _rev_num_cells=_rev_num_cells->deepCpy();
+ _rev_num_cells=_rev_num_cells->deepCopy();
}
/*!
* \return MEDCouplingMesh * - a pointer to MEDCouplingMesh that the caller is to
* delete using decrRef() as it is no more needed.
*/
-MEDCouplingMesh *MEDFileStructuredMesh::getGenMeshAtLevel(int meshDimRelToMax, bool renum) const
+MEDCouplingMesh *MEDFileStructuredMesh::getMeshAtLevel(int meshDimRelToMax, bool renum) const
{
+ checkCartesian();
if(renum)
throw INTERP_KERNEL::Exception("MEDFileCurveLinearMesh does not support renumbering ! To do it perform request of renum array directly !");
const MEDCouplingStructuredMesh *m(getStructuredMesh());
switch(meshDimRelToMax)
- {
+ {
case 0:
{
if(m)
case -1:
{
if(!m)
- throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::getGenMeshAtLevel : level -1 requested must be non empty to be able to compute unstructured sub mesh !");
- return m->build1SGTSubLevelMesh();
+ throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::getMeshAtLevel : level -1 requested must be non empty to be able to compute unstructured sub mesh !");
+ buildMinusOneImplicitPartIfNeeded();
+ MEDCoupling1SGTUMesh *ret(_faces_if_necessary);
+ if(ret)
+ ret->incrRef();
+ return ret;
}
default:
throw INTERP_KERNEL::Exception("MEDFileCurveLinearMesh does not support multi level for mesh 0 expected as input !");
- }
+ }
+}
+
+std::vector<int> MEDFileStructuredMesh::getFamsNonEmptyLevels(const std::vector<std::string>& fams) const
+{
+ std::vector<int> ret;
+ const DataArrayInt *famCells(_fam_cells),*famFaces(_fam_faces);
+ if(famCells && famCells->presenceOfValue(ret))
+ ret.push_back(0);
+ if(famFaces && famFaces->presenceOfValue(ret))
+ ret.push_back(-1);
+ return ret;
+}
+
+std::vector<int> MEDFileStructuredMesh::getFamsNonEmptyLevelsExt(const std::vector<std::string>& fams) const
+{
+ std::vector<int> ret(getFamsNonEmptyLevels(fams));
+ const DataArrayInt *famNodes(_fam_nodes);
+ if(famNodes && famNodes->presenceOfValue(ret))
+ ret.push_back(1);
+ return ret;
}
/*!
if(!cmesh)
throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::getSizeAtLevel : No structured mesh set !");
switch(meshDimRelToMaxExt)
- {
+ {
case 0:
return cmesh->getNumberOfCells();
case 1:
return cmesh->getNumberOfCellsOfSubLevelMesh();
default:
throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::getSizeAtLevel : Only available for levels 0 or 1 or -1 !");
- }
+ }
}
int MEDFileStructuredMesh::getNumberOfNodes() const
return cmesh->getNumberOfNodes();
}
+int MEDFileStructuredMesh::getNumberOfCellsAtLevel(int meshDimRelToMaxExt) const
+{
+ const MEDCouplingStructuredMesh *cmesh(getStructuredMesh());
+ if(!cmesh)
+ throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::getNumberOfNodes : no cartesian mesh set !");
+ switch(meshDimRelToMaxExt)
+ {
+ case 0:
+ return cmesh->getNumberOfCells();
+ case -1:
+ return cmesh->getNumberOfCellsOfSubLevelMesh();
+ default:
+ throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::getNumberOfNodes : only meshDimRelToMax=0 and meshDimRelToMax=-1 supported !");
+ }
+}
+
+bool MEDFileStructuredMesh::hasImplicitPart() const
+{
+ return true;
+}
+
+/*!
+ * \sa MEDFileStructuredMesh::getImplicitFaceMesh
+ */
+int MEDFileStructuredMesh::buildImplicitPartIfAny(INTERP_KERNEL::NormalizedCellType gt) const
+{
+ static const char MSG[]="MEDFileStructuredMesh::buildImplicitPartIfAny : the given geo type is not manageable by a structured mesh !";
+ const MEDCoupling1SGTUMesh *zeFaceMesh(_faces_if_necessary);
+ if(!zeFaceMesh)
+ {
+ const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel(MEDCouplingStructuredMesh::GetGeoTypeGivenMeshDimension(getMeshDimension())));
+ if(cm.getReverseExtrudedType()!=gt)
+ throw INTERP_KERNEL::Exception(MSG);
+ buildImplicitPart();
+ return getStructuredMesh()->getNumberOfCellsOfSubLevelMesh();
+ }
+ else
+ {
+ if(gt!=zeFaceMesh->getCellModelEnum())
+ throw INTERP_KERNEL::Exception(MSG);
+ return zeFaceMesh->getNumberOfCells();
+ }
+}
+
+void MEDFileStructuredMesh::buildMinusOneImplicitPartIfNeeded() const
+{
+ const MEDCoupling1SGTUMesh *zeFaceMesh(_faces_if_necessary);
+ if(!zeFaceMesh)
+ buildImplicitPart();
+}
+
+void MEDFileStructuredMesh::buildImplicitPart() const
+{
+ const MEDCouplingStructuredMesh *mcmesh(getStructuredMesh());
+ if(!mcmesh)
+ throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::buildImplicitPart : Unable to build the implicit part of structured mesh because no structured mesh at level 0 defined !");
+ _faces_if_necessary=mcmesh->build1SGTSubLevelMesh();
+}
+
+void MEDFileStructuredMesh::releaseImplicitPartIfAny() const
+{
+ _faces_if_necessary=0;
+}
+
+/*!
+ * Retrieves the internal pointer (no decrRef requested) of the implicit face mesh if any.
+ * To force to build it you can invoke MEDFileStructuredMesh::buildImplicitPartIfAny method.
+ *
+ * \sa MEDFileStructuredMesh::buildImplicitPartIfAny
+ */
+MEDCoupling1SGTUMesh *MEDFileStructuredMesh::getImplicitFaceMesh() const
+{
+ checkCartesian();
+ return _faces_if_necessary;
+}
+
std::vector<INTERP_KERNEL::NormalizedCellType> MEDFileStructuredMesh::getGeoTypesAtLevel(int meshDimRelToMax) const
{
const MEDCouplingStructuredMesh *cmesh(getStructuredMesh());
if(!cmesh)
throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::getGeoTypesAtLevel : No structured mesh set !");
switch(meshDimRelToMax)
- {
+ {
case 0:
{
std::vector<INTERP_KERNEL::NormalizedCellType> ret(1,cmesh->getTypeOfCell(0));
}
default:
throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::getGeoTypesAtLevel : only 2 levels available at most : 0 and -1 !");
- }
+ }
+}
+
+int MEDFileStructuredMesh::getNumberOfCellsWithType(INTERP_KERNEL::NormalizedCellType ct) const
+{
+ if(ct!=MEDCouplingStructuredMesh::GetGeoTypeGivenMeshDimension(getMeshDimension()))
+ return 0;
+ else
+ return getNumberOfCellsAtLevel(0);
}
void MEDFileStructuredMesh::whichAreNodesFetched(const MEDFileField1TSStructItem& st, const MEDFileFieldGlobsReal *globs, std::vector<bool>& nodesFetched) const
}
void MEDFileStructuredMesh::LoadStrMeshDAFromFile(med_idt fid, int meshDim, int dt, int it, const std::string& mName, MEDFileMeshReadSelector *mrs,
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt>& famCells, MEDCouplingAutoRefCountObjectPtr<DataArrayInt>& numCells, MEDCouplingAutoRefCountObjectPtr<DataArrayAsciiChar>& namesCells)
+ MCAuto<DataArrayInt>& famCells, MCAuto<DataArrayInt>& numCells, MCAuto<DataArrayAsciiChar>& namesCells)
{
med_bool chgt=MED_FALSE,trsf=MED_FALSE;
med_geometry_type geoTypeReq=MEDFileStructuredMesh::GetGeoTypeFromMeshDim(meshDim);
{
famCells=DataArrayInt::New();
famCells->alloc(nbOfElt,1);
- MEDmeshEntityFamilyNumberRd(fid,mName.c_str(),dt,it,MED_CELL,geoTypeReq,famCells->getPointer());
+ MEDFILESAFECALLERRD0(MEDmeshEntityFamilyNumberRd,(fid,mName.c_str(),dt,it,MED_CELL,geoTypeReq,famCells->getPointer()));
}
}
nbOfElt=MEDmeshnEntity(fid,mName.c_str(),dt,it,MED_CELL,geoTypeReq,MED_NUMBER,MED_NODAL,&chgt,&trsf);
{
numCells=DataArrayInt::New();
numCells->alloc(nbOfElt,1);
- MEDmeshEntityNumberRd(fid,mName.c_str(),dt,it,MED_CELL,geoTypeReq,numCells->getPointer());
+ MEDFILESAFECALLERRD0(MEDmeshEntityNumberRd,(fid,mName.c_str(),dt,it,MED_CELL,geoTypeReq,numCells->getPointer()));
}
}
nbOfElt=MEDmeshnEntity(fid,mName.c_str(),dt,it,MED_CELL,geoTypeReq,MED_NAME,MED_NODAL,&chgt,&trsf);
{
namesCells=DataArrayAsciiChar::New();
namesCells->alloc(nbOfElt+1,MED_SNAME_SIZE);//not a bug to avoid the memory corruption due to last \0 at the end
- MEDmeshEntityNameRd(fid,mName.c_str(),dt,it,MED_CELL,geoTypeReq,namesCells->getPointer());
+ MEDFILESAFECALLERRD0(MEDmeshEntityNameRd,(fid,mName.c_str(),dt,it,MED_CELL,geoTypeReq,namesCells->getPointer()));
namesCells->reAlloc(nbOfElt);//not a bug to avoid the memory corruption due to last \0 at the end
}
}
setTimeUnit(strm->getTimeUnit());
MEDFileMeshL2::ReadFamiliesAndGrps(fid,mName,_families,_groups,mrs);
med_bool chgt=MED_FALSE,trsf=MED_FALSE;
- int nbOfElt=MEDmeshnEntity(fid,mName.c_str(),dt,it,MED_NODE,MED_NONE,MED_FAMILY_NUMBER,MED_NODAL,&chgt,&trsf);
+ int nbOfElt(MEDmeshnEntity(fid,mName.c_str(),dt,it,MED_NODE,MED_NONE,MED_FAMILY_NUMBER,MED_NODAL,&chgt,&trsf));
if(nbOfElt>0)
{
if(!mrs || mrs->isNodeFamilyFieldReading())
_fam_nodes->alloc(nbNodes,1);//yes nbNodes and not nbOfElt see next line.
if(nbNodes>nbOfElt)//yes it appends some times... It explains surely the mdump implementation. Bug revealed by PARAVIS EDF #2475 on structured.med file where only 12 first nodes are !=0 so nbOfElt=12 and nbOfNodes=378...
_fam_nodes->fillWithZero();
- MEDmeshEntityFamilyNumberRd(fid,mName.c_str(),dt,it,MED_NODE,MED_NONE,_fam_nodes->getPointer());
+ MEDFILESAFECALLERRD0(MEDmeshEntityFamilyNumberRd,(fid,mName.c_str(),dt,it,MED_NODE,MED_NONE,_fam_nodes->getPointer()));
}
}
nbOfElt=MEDmeshnEntity(fid,mName.c_str(),dt,it,MED_NODE,MED_NONE,MED_NUMBER,MED_NODAL,&chgt,&trsf);
{
_num_nodes=DataArrayInt::New();
_num_nodes->alloc(nbOfElt,1);
- MEDmeshEntityNumberRd(fid,mName.c_str(),dt,it,MED_NODE,MED_NONE,_num_nodes->getPointer());
+ MEDFILESAFECALLERRD0(MEDmeshEntityNumberRd,(fid,mName.c_str(),dt,it,MED_NODE,MED_NONE,_num_nodes->getPointer()));
}
}
nbOfElt=MEDmeshnEntity(fid,mName.c_str(),dt,it,MED_NODE,MED_NONE,MED_NAME,MED_NODAL,&chgt,&trsf);
{
_names_nodes=DataArrayAsciiChar::New();
_names_nodes->alloc(nbOfElt+1,MED_SNAME_SIZE);//not a bug to avoid the memory corruption due to last \0 at the end
- MEDmeshEntityNameRd(fid,mName.c_str(),dt,it,MED_NODE,MED_NONE,_names_nodes->getPointer());
+ MEDFILESAFECALLERRD0(MEDmeshEntityNameRd,(fid,mName.c_str(),dt,it,MED_NODE,MED_NONE,_names_nodes->getPointer()));
_names_nodes->reAlloc(nbOfElt);//not a bug to avoid the memory corruption due to last \0 at the end
}
}
med_geometry_type geoTypeReq(GetGeoTypeFromMeshDim(meshDim)),geoTypeReq2(GetGeoTypeFromMeshDim(meshDim-1));
//
if((const DataArrayInt *)_fam_cells)
- MEDmeshEntityFamilyNumberWr(fid,maa.c_str(),_iteration,_order,MED_CELL,geoTypeReq,_fam_cells->getNumberOfTuples(),_fam_cells->getConstPointer());
+ MEDFILESAFECALLERWR0(MEDmeshEntityFamilyNumberWr,(fid,maa.c_str(),_iteration,_order,MED_CELL,geoTypeReq,_fam_cells->getNumberOfTuples(),_fam_cells->getConstPointer()));
if((const DataArrayInt *)_fam_faces)
- MEDmeshEntityFamilyNumberWr(fid,maa.c_str(),_iteration,_order,MED_CELL,geoTypeReq2,_fam_faces->getNumberOfTuples(),_fam_faces->getConstPointer());
+ MEDFILESAFECALLERWR0(MEDmeshEntityFamilyNumberWr,(fid,maa.c_str(),_iteration,_order,MED_CELL,geoTypeReq2,_fam_faces->getNumberOfTuples(),_fam_faces->getConstPointer()));
if((const DataArrayInt *)_fam_nodes)
- MEDmeshEntityFamilyNumberWr(fid,maa.c_str(),_iteration,_order,MED_NODE,MED_NONE,_fam_nodes->getNumberOfTuples(),_fam_nodes->getConstPointer());
+ MEDFILESAFECALLERWR0(MEDmeshEntityFamilyNumberWr,(fid,maa.c_str(),_iteration,_order,MED_NODE,MED_NONE,_fam_nodes->getNumberOfTuples(),_fam_nodes->getConstPointer()));
if((const DataArrayInt *)_num_cells)
- MEDmeshEntityNumberWr(fid,maa.c_str(),_iteration,_order,MED_CELL,geoTypeReq,_num_cells->getNumberOfTuples(),_num_cells->getConstPointer());
+ MEDFILESAFECALLERWR0(MEDmeshEntityNumberWr,(fid,maa.c_str(),_iteration,_order,MED_CELL,geoTypeReq,_num_cells->getNumberOfTuples(),_num_cells->getConstPointer()));
if((const DataArrayInt *)_num_faces)
- MEDmeshEntityNumberWr(fid,maa.c_str(),_iteration,_order,MED_CELL,geoTypeReq2,_num_faces->getNumberOfTuples(),_num_faces->getConstPointer());
+ MEDFILESAFECALLERWR0(MEDmeshEntityNumberWr,(fid,maa.c_str(),_iteration,_order,MED_CELL,geoTypeReq2,_num_faces->getNumberOfTuples(),_num_faces->getConstPointer()));
if((const DataArrayInt *)_num_nodes)
- MEDmeshEntityNumberWr(fid,maa.c_str(),_iteration,_order,MED_NODE,MED_NONE,_num_nodes->getNumberOfTuples(),_num_nodes->getConstPointer());
+ MEDFILESAFECALLERWR0(MEDmeshEntityNumberWr,(fid,maa.c_str(),_iteration,_order,MED_NODE,MED_NONE,_num_nodes->getNumberOfTuples(),_num_nodes->getConstPointer()));
if((const DataArrayAsciiChar *)_names_cells)
{
if(_names_cells->getNumberOfComponents()!=MED_SNAME_SIZE)
oss << " ! The array has " << _names_cells->getNumberOfComponents() << " components !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
- MEDmeshEntityNameWr(fid,maa.c_str(),_iteration,_order,MED_CELL,geoTypeReq,_names_cells->getNumberOfTuples(),_names_cells->getConstPointer());
+ MEDFILESAFECALLERWR0(MEDmeshEntityNameWr,(fid,maa.c_str(),_iteration,_order,MED_CELL,geoTypeReq,_names_cells->getNumberOfTuples(),_names_cells->getConstPointer()));
}
if((const DataArrayAsciiChar *)_names_faces)
{
oss << " ! The array has " << _names_faces->getNumberOfComponents() << " components !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
- MEDmeshEntityNameWr(fid,maa.c_str(),_iteration,_order,MED_CELL,geoTypeReq2,_names_faces->getNumberOfTuples(),_names_faces->getConstPointer());
+ MEDFILESAFECALLERWR0(MEDmeshEntityNameWr,(fid,maa.c_str(),_iteration,_order,MED_CELL,geoTypeReq2,_names_faces->getNumberOfTuples(),_names_faces->getConstPointer()));
}
if((const DataArrayAsciiChar *)_names_nodes)
{
oss << " ! The array has " << _names_cells->getNumberOfComponents() << " components !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
- MEDmeshEntityNameWr(fid,maa.c_str(),_iteration,_order,MED_NODE,MED_NONE,_names_nodes->getNumberOfTuples(),_names_nodes->getConstPointer());
+ MEDFILESAFECALLERWR0(MEDmeshEntityNameWr,(fid,maa.c_str(),_iteration,_order,MED_NODE,MED_NONE,_names_nodes->getNumberOfTuples(),_names_nodes->getConstPointer()));
}
//
MEDFileUMeshL2::WriteFamiliesAndGrps(fid,maa.c_str(),_families,_groups,_too_long_str);
*/
MEDFileCMesh *MEDFileCMesh::New(const std::string& fileName, MEDFileMeshReadSelector *mrs)
{
- std::vector<std::string> ms=MEDLoader::GetMeshNames(fileName);
+ std::vector<std::string> ms(MEDCoupling::GetMeshNames(fileName));
if(ms.empty())
{
std::ostringstream oss; oss << "MEDFileUMesh::New : no meshes in file \"" << fileName << "\" !";
MEDFileUtilities::CheckFileForRead(fileName);
MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
int dt,it;
- ParaMEDMEM::MEDCouplingMeshType meshType;
+ MEDCoupling::MEDCouplingMeshType meshType;
std::string dummy2;
- MEDFileMeshL2::GetMeshIdFromName(fid,ms.front(),meshType,dt,it,dummy2);
+ MEDCoupling::MEDCouplingAxisType dummy3;
+ MEDFileMeshL2::GetMeshIdFromName(fid,ms.front(),meshType,dummy3,dt,it,dummy2);
return new MEDFileCMesh(fid,ms.front(),dt,it,mrs);
}
return MEDFileStructuredMesh::getHeapMemorySizeWithoutChildren();
}
-std::vector<const BigMemoryObject *> MEDFileCMesh::getDirectChildren() const
+std::vector<const BigMemoryObject *> MEDFileCMesh::getDirectChildrenWithNull() const
{
- std::vector<const BigMemoryObject *> ret(MEDFileStructuredMesh::getDirectChildren());
- if((const MEDCouplingCMesh *)_cmesh)
- ret.push_back((const MEDCouplingCMesh *)_cmesh);
+ std::vector<const BigMemoryObject *> ret(MEDFileStructuredMesh::getDirectChildrenWithNull());
+ ret.push_back((const MEDCouplingCMesh *)_cmesh);
return ret;
}
return simpleRepr();
}
-MEDFileMesh *MEDFileCMesh::shallowCpy() const
+MEDFileCMesh *MEDFileCMesh::shallowCpy() const
{
- MEDCouplingAutoRefCountObjectPtr<MEDFileCMesh> ret=new MEDFileCMesh(*this);
+ MCAuto<MEDFileCMesh> ret(new MEDFileCMesh(*this));
return ret.retn();
}
return new MEDFileCMesh;
}
-MEDFileMesh *MEDFileCMesh::deepCpy() const
+MEDFileCMesh *MEDFileCMesh::deepCopy() const
{
- MEDCouplingAutoRefCountObjectPtr<MEDFileCMesh> ret=new MEDFileCMesh(*this);
+ MCAuto<MEDFileCMesh> ret(new MEDFileCMesh(*this));
+ ret->deepCpyEquivalences(*this);
if((const MEDCouplingCMesh*)_cmesh)
- ret->_cmesh=static_cast<MEDCouplingCMesh*>(_cmesh->deepCpy());
+ ret->_cmesh=static_cast<MEDCouplingCMesh*>(_cmesh->deepCopy());
ret->deepCpyAttributes();
return ret.retn();
}
MEDFileCMesh::MEDFileCMesh(med_idt fid, const std::string& mName, int dt, int it, MEDFileMeshReadSelector *mrs)
try
- {
- loadCMeshFromFile(fid,mName,dt,it,mrs);
- }
+{
+ loadLLWithAdditionalItems(fid,mName,dt,it,mrs);
+}
catch(INTERP_KERNEL::Exception& e)
- {
+{
throw e;
- }
+}
-void MEDFileCMesh::loadCMeshFromFile(med_idt fid, const std::string& mName, int dt, int it, MEDFileMeshReadSelector *mrs)
+void MEDFileCMesh::loadLL(med_idt fid, const std::string& mName, int dt, int it, MEDFileMeshReadSelector *mrs)
{
- ParaMEDMEM::MEDCouplingMeshType meshType;
+ MEDCoupling::MEDCouplingMeshType meshType;
int dummy0,dummy1;
std::string dtunit;
- int mid=MEDFileMeshL2::GetMeshIdFromName(fid,mName,meshType,dummy0,dummy1,dtunit);
+ MEDCoupling::MEDCouplingAxisType axType;
+ int mid=MEDFileMeshL2::GetMeshIdFromName(fid,mName,meshType,axType,dummy0,dummy1,dtunit);
if(meshType!=CARTESIAN)
{
std::ostringstream oss; oss << "Trying to load as cartesian an existing mesh with name '" << mName << "' that is NOT cartesian !";
}
MEDFileCMeshL2 loaderl2;
loaderl2.loadAll(fid,mid,mName,dt,it);
+ setAxisType(axType);
MEDCouplingCMesh *mesh=loaderl2.getMesh();
mesh->incrRef();
_cmesh=mesh;
_cmesh=m;
}
+MEDFileMesh *MEDFileCMesh::cartesianize() const
+{
+ if(getAxisType()==AX_CART)
+ {
+ incrRef();
+ return const_cast<MEDFileCMesh *>(this);
+ }
+ else
+ {
+ const MEDCouplingCMesh *cmesh(getMesh());
+ if(!cmesh)
+ throw INTERP_KERNEL::Exception("MEDFileCMesh::cartesianize : impossible to turn into cartesian because the mesh is null !");
+ MCAuto<MEDCouplingCurveLinearMesh> clmesh(cmesh->buildCurveLinear());
+ MCAuto<DataArrayDouble> coords(clmesh->getCoords()->cartesianize(getAxisType()));
+ clmesh->setCoords(coords);
+ MCAuto<MEDFileCurveLinearMesh> ret(MEDFileCurveLinearMesh::New());
+ ret->MEDFileStructuredMesh::operator=(*this);
+ ret->setMesh(clmesh);
+ ret->setAxisType(AX_CART);
+ return ret.retn();
+ }
+}
+
void MEDFileCMesh::writeLL(med_idt fid) const
{
INTERP_KERNEL::AutoPtr<char> maa=MEDLoaderBase::buildEmptyString(MED_NAME_SIZE);
MEDLoaderBase::safeStrCpy2(c.c_str(),MED_SNAME_SIZE-1,comp+i*MED_SNAME_SIZE,_too_long_str);//MED_TAILLE_PNOM-1 to avoid to write '\0' on next compo
MEDLoaderBase::safeStrCpy2(u.c_str(),MED_SNAME_SIZE-1,unit+i*MED_SNAME_SIZE,_too_long_str);//MED_TAILLE_PNOM-1 to avoid to write '\0' on next compo
}
- MEDmeshCr(fid,maa,spaceDim,spaceDim,MED_STRUCTURED_MESH,desc,dtunit,MED_SORT_DTIT,MED_CARTESIAN,comp,unit);
- MEDmeshUniversalNameWr(fid,maa);
- MEDmeshGridTypeWr(fid,maa,MED_CARTESIAN_GRID);
+ MEDFILESAFECALLERWR0(MEDmeshCr,(fid,maa,spaceDim,spaceDim,MED_STRUCTURED_MESH,desc,dtunit,MED_SORT_DTIT,MEDFileMeshL2::TraduceAxisTypeRev(getAxisType()),comp,unit));
+ if(_univ_wr_status)
+ MEDFILESAFECALLERWR0(MEDmeshUniversalNameWr,(fid,maa));
+ MEDFILESAFECALLERWR0(MEDmeshGridTypeWr,(fid,maa,MEDFileMeshL2::TraduceAxisTypeRevStruct(getAxisType())));
for(int i=0;i<spaceDim;i++)
{
const DataArrayDouble *da=_cmesh->getCoordsAt(i);
- MEDmeshGridIndexCoordinateWr(fid,maa,_iteration,_order,_time,i+1,da->getNumberOfTuples(),da->getConstPointer());
+ MEDFILESAFECALLERWR0(MEDmeshGridIndexCoordinateWr,(fid,maa,_iteration,_order,_time,i+1,da->getNumberOfTuples(),da->getConstPointer()));
}
//
std::string meshName(MEDLoaderBase::buildStringFromFortran(maa,MED_NAME_SIZE));
MEDFileCurveLinearMesh *MEDFileCurveLinearMesh::New(const std::string& fileName, MEDFileMeshReadSelector *mrs)
{
- std::vector<std::string> ms=MEDLoader::GetMeshNames(fileName);
+ std::vector<std::string> ms(MEDCoupling::GetMeshNames(fileName));
if(ms.empty())
{
std::ostringstream oss; oss << "MEDFileUMesh::New : no meshes in file \"" << fileName << "\" !";
MEDFileUtilities::CheckFileForRead(fileName);
MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
int dt,it;
- ParaMEDMEM::MEDCouplingMeshType meshType;
+ MEDCoupling::MEDCouplingMeshType meshType;
+ MEDCoupling::MEDCouplingAxisType dummy3;
std::string dummy2;
- MEDFileMeshL2::GetMeshIdFromName(fid,ms.front(),meshType,dt,it,dummy2);
+ MEDFileMeshL2::GetMeshIdFromName(fid,ms.front(),meshType,dummy3,dt,it,dummy2);
return new MEDFileCurveLinearMesh(fid,ms.front(),dt,it,mrs);
}
return MEDFileStructuredMesh::getHeapMemorySizeWithoutChildren();
}
-std::vector<const BigMemoryObject *> MEDFileCurveLinearMesh::getDirectChildren() const
+std::vector<const BigMemoryObject *> MEDFileCurveLinearMesh::getDirectChildrenWithNull() const
{
- std::vector<const BigMemoryObject *> ret(MEDFileStructuredMesh::getDirectChildren());
- if((const MEDCouplingCurveLinearMesh *)_clmesh)
- ret.push_back((const MEDCouplingCurveLinearMesh *)_clmesh);
+ std::vector<const BigMemoryObject *> ret(MEDFileStructuredMesh::getDirectChildrenWithNull());
+ ret.push_back((const MEDCouplingCurveLinearMesh *)_clmesh);
return ret;
}
-MEDFileMesh *MEDFileCurveLinearMesh::shallowCpy() const
+MEDFileCurveLinearMesh *MEDFileCurveLinearMesh::shallowCpy() const
{
- MEDCouplingAutoRefCountObjectPtr<MEDFileCurveLinearMesh> ret=new MEDFileCurveLinearMesh(*this);
+ MCAuto<MEDFileCurveLinearMesh> ret(new MEDFileCurveLinearMesh(*this));
return ret.retn();
}
return new MEDFileCurveLinearMesh;
}
-MEDFileMesh *MEDFileCurveLinearMesh::deepCpy() const
+MEDFileCurveLinearMesh *MEDFileCurveLinearMesh::deepCopy() const
{
- MEDCouplingAutoRefCountObjectPtr<MEDFileCurveLinearMesh> ret=new MEDFileCurveLinearMesh(*this);
+ MCAuto<MEDFileCurveLinearMesh> ret(new MEDFileCurveLinearMesh(*this));
+ ret->deepCpyEquivalences(*this);
if((const MEDCouplingCurveLinearMesh*)_clmesh)
- ret->_clmesh=static_cast<MEDCouplingCurveLinearMesh*>(_clmesh->deepCpy());
+ ret->_clmesh=static_cast<MEDCouplingCurveLinearMesh*>(_clmesh->deepCopy());
ret->deepCpyAttributes();
return ret.retn();
}
_clmesh=m;
}
+MEDFileMesh *MEDFileCurveLinearMesh::cartesianize() const
+{
+ if(getAxisType()==AX_CART)
+ {
+ incrRef();
+ return const_cast<MEDFileCurveLinearMesh *>(this);
+ }
+ else
+ {
+ const MEDCouplingCurveLinearMesh *mesh(getMesh());
+ if(!mesh)
+ throw INTERP_KERNEL::Exception("MEDFileCurveLinearMesh::cartesianize : impossible to turn into cartesian because the mesh is null !");
+ const DataArrayDouble *coords(mesh->getCoords());
+ if(!coords)
+ throw INTERP_KERNEL::Exception("MEDFileCurveLinearMesh::cartesianize : coordinate pointer in mesh is null !");
+ MCAuto<MEDFileCurveLinearMesh> ret(new MEDFileCurveLinearMesh(*this));
+ MCAuto<MEDCouplingCurveLinearMesh> mesh2(mesh->clone(false));
+ MCAuto<DataArrayDouble> coordsCart(coords->cartesianize(getAxisType()));
+ mesh2->setCoords(coordsCart);
+ ret->setMesh(mesh2);
+ ret->setAxisType(AX_CART);
+ return ret.retn();
+ }
+}
+
const MEDCouplingStructuredMesh *MEDFileCurveLinearMesh::getStructuredMesh() const
{
synchronizeTinyInfoOnLeaves();
MEDFileCurveLinearMesh::MEDFileCurveLinearMesh(med_idt fid, const std::string& mName, int dt, int it, MEDFileMeshReadSelector *mrs)
try
- {
- loadCLMeshFromFile(fid,mName,dt,it,mrs);
- }
+{
+ loadLLWithAdditionalItems(fid,mName,dt,it,mrs);
+}
catch(INTERP_KERNEL::Exception& e)
- {
+{
throw e;
- }
+}
void MEDFileCurveLinearMesh::writeLL(med_idt fid) const
{
MEDLoaderBase::safeStrCpy2(c.c_str(),MED_SNAME_SIZE-1,comp+i*MED_SNAME_SIZE,_too_long_str);//MED_TAILLE_PNOM-1 to avoid to write '\0' on next compo
MEDLoaderBase::safeStrCpy2(u.c_str(),MED_SNAME_SIZE-1,unit+i*MED_SNAME_SIZE,_too_long_str);//MED_TAILLE_PNOM-1 to avoid to write '\0' on next compo
}
- MEDmeshCr(fid,maa,spaceDim,meshDim,MED_STRUCTURED_MESH,desc,dtunit,MED_SORT_DTIT,MED_CARTESIAN,comp,unit);
- MEDmeshUniversalNameWr(fid,maa);
- MEDmeshGridTypeWr(fid,maa,MED_CURVILINEAR_GRID);
+ MEDFILESAFECALLERWR0(MEDmeshCr,(fid,maa,spaceDim,meshDim,MED_STRUCTURED_MESH,desc,dtunit,MED_SORT_DTIT,MEDFileMeshL2::TraduceAxisTypeRev(getAxisType()),comp,unit));
+ if(_univ_wr_status)
+ MEDFILESAFECALLERWR0(MEDmeshUniversalNameWr,(fid,maa));
+ MEDFILESAFECALLERWR0(MEDmeshGridTypeWr,(fid,maa,MED_CURVILINEAR_GRID));
std::vector<int> nodeGridSt=_clmesh->getNodeGridStructure();
- MEDmeshGridStructWr(fid,maa,_iteration,_order,_time,&nodeGridSt[0]);
-
- MEDmeshNodeCoordinateWr(fid,maa,_iteration,_order,_time,MED_FULL_INTERLACE,coords->getNumberOfTuples(),coords->begin());
+ MEDFILESAFECALLERWR0(MEDmeshGridStructWr,(fid,maa,_iteration,_order,_time,&nodeGridSt[0]));
+
+ MEDFILESAFECALLERWR0(MEDmeshNodeCoordinateWr,(fid,maa,_iteration,_order,_time,MED_FULL_INTERLACE,coords->getNumberOfTuples(),coords->begin()));
//
std::string meshName(MEDLoaderBase::buildStringFromFortran(maa,MED_NAME_SIZE));
MEDFileStructuredMesh::writeStructuredLL(fid,meshName);
}
-void MEDFileCurveLinearMesh::loadCLMeshFromFile(med_idt fid, const std::string& mName, int dt, int it, MEDFileMeshReadSelector *mrs)
+void MEDFileCurveLinearMesh::loadLL(med_idt fid, const std::string& mName, int dt, int it, MEDFileMeshReadSelector *mrs)
{
- ParaMEDMEM::MEDCouplingMeshType meshType;
+ MEDCoupling::MEDCouplingMeshType meshType;
int dummy0,dummy1;
std::string dtunit;
- int mid=MEDFileMeshL2::GetMeshIdFromName(fid,mName,meshType,dummy0,dummy1,dtunit);
+ MEDCoupling::MEDCouplingAxisType axType;
+ int mid=MEDFileMeshL2::GetMeshIdFromName(fid,mName,meshType,axType,dummy0,dummy1,dtunit);
+ setAxisType(axType);
if(meshType!=CURVE_LINEAR)
{
std::ostringstream oss; oss << "Trying to load as curve linear an existing mesh with name '" << mName << "' that is NOT curve linear !";
return new MEDFileMeshMultiTS(fileName,mName);
}
-MEDFileMeshMultiTS *MEDFileMeshMultiTS::deepCpy() const
+MEDFileMeshMultiTS *MEDFileMeshMultiTS::deepCopy() const
{
- MEDCouplingAutoRefCountObjectPtr<MEDFileMeshMultiTS> ret=MEDFileMeshMultiTS::New();
- std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileMesh> > meshOneTs(_mesh_one_ts.size());
+ MCAuto<MEDFileMeshMultiTS> ret=MEDFileMeshMultiTS::New();
+ std::vector< MCAuto<MEDFileMesh> > meshOneTs(_mesh_one_ts.size());
std::size_t i=0;
- for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileMesh> >::const_iterator it=_mesh_one_ts.begin();it!=_mesh_one_ts.end();it++,i++)
+ for(std::vector< MCAuto<MEDFileMesh> >::const_iterator it=_mesh_one_ts.begin();it!=_mesh_one_ts.end();it++,i++)
if((const MEDFileMesh *)*it)
- meshOneTs[i]=(*it)->deepCpy();
+ meshOneTs[i]=(*it)->deepCopy();
ret->_mesh_one_ts=meshOneTs;
return ret.retn();
}
std::size_t MEDFileMeshMultiTS::getHeapMemorySizeWithoutChildren() const
{
- return _mesh_one_ts.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr<MEDFileMesh>);
+ return _mesh_one_ts.capacity()*sizeof(MCAuto<MEDFileMesh>);
}
-std::vector<const BigMemoryObject *> MEDFileMeshMultiTS::getDirectChildren() const
+std::vector<const BigMemoryObject *> MEDFileMeshMultiTS::getDirectChildrenWithNull() const
{
std::vector<const BigMemoryObject *> ret;
- for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileMesh> >::const_iterator it=_mesh_one_ts.begin();it!=_mesh_one_ts.end();it++)
- {
- const MEDFileMesh *cur(*it);
- if(cur)
- ret.push_back(cur);
- }
+ for(std::vector< MCAuto<MEDFileMesh> >::const_iterator it=_mesh_one_ts.begin();it!=_mesh_one_ts.end();it++)
+ ret.push_back((const MEDFileMesh *)*it);
return ret;
}
bool MEDFileMeshMultiTS::changeNames(const std::vector< std::pair<std::string,std::string> >& modifTab)
{
bool ret=false;
- for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileMesh> >::iterator it=_mesh_one_ts.begin();it!=_mesh_one_ts.end();it++)
+ for(std::vector< MCAuto<MEDFileMesh> >::iterator it=_mesh_one_ts.begin();it!=_mesh_one_ts.end();it++)
{
MEDFileMesh *cur(*it);
if(cur)
return ret;
}
+void MEDFileMeshMultiTS::cartesianizeMe()
+{
+ for(std::vector< MCAuto<MEDFileMesh> >::iterator it=_mesh_one_ts.begin();it!=_mesh_one_ts.end();it++)
+ {
+ MEDFileMesh *cur(*it);
+ if(cur)
+ {
+ MCAuto<MEDFileMesh> ccur(cur->cartesianize());// Attention ! Do not wrap these two lines because memory leak !
+ *it=ccur;
+ }
+ }
+}
+
MEDFileMesh *MEDFileMeshMultiTS::getOneTimeStep() const
{
if(_mesh_one_ts.empty())
throw INTERP_KERNEL::Exception("MEDFileMeshMultiTS::setOneTimeStep : input pointer should be different from 0 !");
_mesh_one_ts.resize(1);
mesh1TimeStep->incrRef();
- //MEDCouplingAutoRefCountObjectPtr<MEDFileMesh> toto=mesh1TimeStep;
+ //MCAuto<MEDFileMesh> toto=mesh1TimeStep;
_mesh_one_ts[0]=mesh1TimeStep;
}
+MEDFileJoints * MEDFileMeshMultiTS::getJoints() const
+{
+ if ( MEDFileMesh* m = getOneTimeStep() )
+ return m->getJoints();
+ return 0;
+}
+
+/*!
+ * \brief Set Joints that are common to all time-stamps
+ */
+void MEDFileMeshMultiTS::setJoints( MEDFileJoints* joints )
+{
+ for(std::vector< MCAuto<MEDFileMesh> >::iterator it=_mesh_one_ts.begin();it!=_mesh_one_ts.end();it++)
+ {
+ (*it)->setJoints( joints );
+ }
+}
+
void MEDFileMeshMultiTS::write(med_idt fid) const
{
- for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileMesh> >::const_iterator it=_mesh_one_ts.begin();it!=_mesh_one_ts.end();it++)
+ MEDFileJoints *joints(getJoints());
+ bool jointsWritten(false);
+
+ for(std::vector< MCAuto<MEDFileMesh> >::const_iterator it=_mesh_one_ts.begin();it!=_mesh_one_ts.end();it++)
{
+ if ( jointsWritten )
+ const_cast<MEDFileMesh&>(**it).setJoints( 0 );
+ else
+ jointsWritten = true;
+
(*it)->copyOptionsFrom(*this);
(*it)->write(fid);
}
+
+ (const_cast<MEDFileMeshMultiTS*>(this))->setJoints( joints ); // restore joints
}
void MEDFileMeshMultiTS::write(const std::string& fileName, int mode) const
}
void MEDFileMeshMultiTS::loadFromFile(const std::string& fileName, const std::string& mName)
-{//for the moment to be improved
- _mesh_one_ts.resize(1);
- _mesh_one_ts[0]=MEDFileMesh::New(fileName,mName,-1,-1);
+{
+ MEDFileJoints* joints = 0;
+ if ( !_mesh_one_ts.empty() && getOneTimeStep() )
+ {
+ // joints of mName already read, pass them to MEDFileMesh::New() to prevent repeated reading
+ joints = getOneTimeStep()->getJoints();
+ }
+
+ _mesh_one_ts.clear(); //for the moment to be improved
+ _mesh_one_ts.push_back( MEDFileMesh::New(fileName,mName,-1,-1,0, joints ));
}
MEDFileMeshMultiTS::MEDFileMeshMultiTS()
MEDFileMeshMultiTS::MEDFileMeshMultiTS(const std::string& fileName)
try
- {
- std::vector<std::string> ms=MEDLoader::GetMeshNames(fileName);
+{
+ std::vector<std::string> ms(MEDCoupling::GetMeshNames(fileName));
if(ms.empty())
- {
- std::ostringstream oss; oss << "MEDFileUMesh::New : no meshes in file \"" << fileName << "\" !";
- throw INTERP_KERNEL::Exception(oss.str().c_str());
- }
+ {
+ std::ostringstream oss; oss << "MEDFileUMesh::New : no meshes in file \"" << fileName << "\" !";
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
+ }
MEDFileUtilities::CheckFileForRead(fileName);
MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
int dt,it;
- ParaMEDMEM::MEDCouplingMeshType meshType;
+ MEDCoupling::MEDCouplingMeshType meshType;
std::string dummy2;
- MEDFileMeshL2::GetMeshIdFromName(fid,ms.front(),meshType,dt,it,dummy2);
+ MEDCoupling::MEDCouplingAxisType dummy3;
+ MEDFileMeshL2::GetMeshIdFromName(fid,ms.front(),meshType,dummy3,dt,it,dummy2);
loadFromFile(fileName,ms.front());
- }
+}
catch(INTERP_KERNEL::Exception& e)
- {
+{
throw e;
- }
+}
MEDFileMeshMultiTS::MEDFileMeshMultiTS(const std::string& fileName, const std::string& mName)
try
- {
+{
loadFromFile(fileName,mName);
- }
+}
catch(INTERP_KERNEL::Exception& e)
- {
+{
throw e;
- }
+}
MEDFileMeshes *MEDFileMeshes::New()
{
void MEDFileMeshes::write(med_idt fid) const
{
- checkCoherency();
- for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileMeshMultiTS> >::const_iterator it=_meshes.begin();it!=_meshes.end();it++)
+ checkConsistencyLight();
+ for(std::vector< MCAuto<MEDFileMeshMultiTS> >::const_iterator it=_meshes.begin();it!=_meshes.end();it++)
{
(*it)->copyOptionsFrom(*this);
(*it)->write(fid);
MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),medmod);
std::ostringstream oss; oss << "MEDFileMesh : error on attempt to write in file : \"" << fileName << "\"";
MEDFileUtilities::CheckMEDCode(fid,fid,oss.str());
- checkCoherency();
+ checkConsistencyLight();
write(fid);
}
return new MEDFileMeshesIterator(this);
}
+/** Return a borrowed reference (caller is not responsible) */
MEDFileMesh *MEDFileMeshes::getMeshAtPos(int i) const
{
if(i<0 || i>=(int)_meshes.size())
return _meshes[i]->getOneTimeStep();
}
+/** Return a borrowed reference (caller is not responsible) */
MEDFileMesh *MEDFileMeshes::getMeshWithName(const std::string& mname) const
{
std::vector<std::string> ms=getMeshesNames();
{
std::vector<std::string> ret(_meshes.size());
int i=0;
- for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileMeshMultiTS> >::const_iterator it=_meshes.begin();it!=_meshes.end();it++,i++)
+ for(std::vector< MCAuto<MEDFileMeshMultiTS> >::const_iterator it=_meshes.begin();it!=_meshes.end();it++,i++)
{
const MEDFileMeshMultiTS *f=(*it);
if(f)
bool MEDFileMeshes::changeNames(const std::vector< std::pair<std::string,std::string> >& modifTab)
{
bool ret=false;
- for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileMeshMultiTS> >::iterator it=_meshes.begin();it!=_meshes.end();it++)
+ for(std::vector< MCAuto<MEDFileMeshMultiTS> >::iterator it=_meshes.begin();it!=_meshes.end();it++)
{
MEDFileMeshMultiTS *cur(*it);
if(cur)
return ret;
}
+void MEDFileMeshes::cartesianizeMe()
+{
+ for(std::vector< MCAuto<MEDFileMeshMultiTS> >::iterator it=_meshes.begin();it!=_meshes.end();it++)
+ {
+ MEDFileMeshMultiTS *cur(*it);
+ if(cur)
+ cur->cartesianizeMe();
+ }
+}
+
void MEDFileMeshes::resize(int newSize)
{
_meshes.resize(newSize);
void MEDFileMeshes::loadFromFile(const std::string& fileName)
{
- std::vector<std::string> ms=MEDLoader::GetMeshNames(fileName);
+ std::vector<std::string> ms(MEDCoupling::GetMeshNames(fileName));
int i=0;
_meshes.resize(ms.size());
for(std::vector<std::string>::const_iterator it=ms.begin();it!=ms.end();it++,i++)
MEDFileMeshes::MEDFileMeshes(const std::string& fileName)
try
- {
+{
loadFromFile(fileName);
- }
+}
catch(INTERP_KERNEL::Exception& /*e*/)
- {
- }
+{
+}
-MEDFileMeshes *MEDFileMeshes::deepCpy() const
+MEDFileMeshes *MEDFileMeshes::deepCopy() const
{
- std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileMeshMultiTS> > meshes(_meshes.size());
+ std::vector< MCAuto<MEDFileMeshMultiTS> > meshes(_meshes.size());
std::size_t i=0;
- for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileMeshMultiTS> >::const_iterator it=_meshes.begin();it!=_meshes.end();it++,i++)
+ for(std::vector< MCAuto<MEDFileMeshMultiTS> >::const_iterator it=_meshes.begin();it!=_meshes.end();it++,i++)
if((const MEDFileMeshMultiTS *)*it)
- meshes[i]=(*it)->deepCpy();
- MEDCouplingAutoRefCountObjectPtr<MEDFileMeshes> ret=MEDFileMeshes::New();
+ meshes[i]=(*it)->deepCopy();
+ MCAuto<MEDFileMeshes> ret=MEDFileMeshes::New();
ret->_meshes=meshes;
return ret.retn();
}
std::size_t MEDFileMeshes::getHeapMemorySizeWithoutChildren() const
{
- return _meshes.capacity()*(sizeof(MEDCouplingAutoRefCountObjectPtr<MEDFileMeshMultiTS>));
+ return _meshes.capacity()*(sizeof(MCAuto<MEDFileMeshMultiTS>));
}
-std::vector<const BigMemoryObject *> MEDFileMeshes::getDirectChildren() const
+std::vector<const BigMemoryObject *> MEDFileMeshes::getDirectChildrenWithNull() const
{
std::vector<const BigMemoryObject *> ret;
- for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileMeshMultiTS> >::const_iterator it=_meshes.begin();it!=_meshes.end();it++)
- {
- const MEDFileMeshMultiTS *cur(*it);
- if(cur)
- ret.push_back(cur);
- }
+ for(std::vector< MCAuto<MEDFileMeshMultiTS> >::const_iterator it=_meshes.begin();it!=_meshes.end();it++)
+ ret.push_back((const MEDFileMeshMultiTS *)*it);
return ret;
}
oss << " - #" << i << " \"" << mns[i] << "\"\n";
}
-void MEDFileMeshes::checkCoherency() const
+void MEDFileMeshes::checkConsistencyLight() const
{
- static const char MSG[]="MEDFileMeshes::checkCoherency : mesh at rank ";
+ static const char MSG[]="MEDFileMeshes::checkConsistencyLight : mesh at rank ";
int i=0;
std::set<std::string> s;
- for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileMeshMultiTS> >::const_iterator it=_meshes.begin();it!=_meshes.end();it++,i++)
+ for(std::vector< MCAuto<MEDFileMeshMultiTS> >::const_iterator it=_meshes.begin();it!=_meshes.end();it++,i++)
{
const MEDFileMeshMultiTS *elt=(*it);
if(!elt)